@mongorm/orm 0.1.1-beta.3 → 0.1.1-beta.4

package/dist/index.d.mts

@@ -127,11 +127,13 @@ export declare class ModelCursor<Shape extends SchemaShape, Result extends objec
 //#endregion
 //#region src/query/types.d.ts
 type StoredDocument<Shape extends SchemaShape> = Infer<Schema<Shape>> & Document;
-type ModelFilterForDocument<DocumentShape extends Document, FieldShape extends object = DocumentShape> = Partial<{ [Key in keyof FieldShape]: Condition<FieldShape[Key]>; }> & Partial<Pick<RootFilterOperators<DocumentShape>, '$comment' | '$expr' | '$jsonSchema' | '$text' | '$where'>> & {
+type ModelFilterForDocument<DocumentShape extends Document, FieldShape extends object = DocumentShape> = Partial<{ [Key in keyof FieldShape]: Condition<FieldShape[Key]>; }> & Partial<{ [Path in NestedFilterKey<FieldShape>]: Condition<NestedFilterValue<FieldShape, Path>>; }> & Partial<Pick<RootFilterOperators<DocumentShape>, '$comment' | '$expr' | '$jsonSchema' | '$text' | '$where'>> & {
   $and?: ModelFilterForDocument<DocumentShape, FieldShape>[];
   $nor?: ModelFilterForDocument<DocumentShape, FieldShape>[];
   $or?: ModelFilterForDocument<DocumentShape, FieldShape>[];
 };
+type NestedFilterKey<Value, Prefix extends string = ''> = Value extends object ? Value extends ObjectId$1 | Date | readonly unknown[] ? never : { [Key in Extract<keyof Value, string>]: NonNullable<Value[Key]> extends object ? `${Prefix}${Key}` | `${Prefix}${Key}.${NestedFilterKey<NonNullable<Value[Key]>>}` : `${Prefix}${Key}`; }[Extract<keyof Value, string>] : never;
+type NestedFilterValue<Value, Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head extends keyof Value ? NestedFilterValue<NonNullable<Value[Head]>, Tail> : never : Path extends keyof Value ? Value[Path] : never;
 type ModelFilter<Shape extends SchemaShape> = ModelFilterForDocument<StoredDocument<Shape>, Infer<Schema<Shape>>>;
 type SortDirection = 'asc' | 'desc';
 type ModelSort<Shape extends SchemaShape> = Partial<Record<Extract<keyof Infer<Schema<Shape>>, string>, SortDirection>>;
@@ -220,11 +222,36 @@ export declare class ModelQuery<Shape extends SchemaShape, Result extends object
   then<TResult1 = Result[], TResult2 = never>(onfulfilled?: ((value: Result[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
 }
 //#endregion
+//#region src/schema/scalars.d.ts
+declare module 'zod' {
+  interface ZodType {
+    hidden(): this & {
+      readonly __hidden: true;
+    };
+  }
+}
+/** A schema field that can be marked as hidden from default query results. */
+type HiddenCapable<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T>;
+/** A schema field marked as hidden from default query results. */
+type HiddenSchema<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T> & {
+  readonly __hidden: true;
+};
+type HiddenMethods<T extends z.ZodType> = {
+  hidden(): HiddenSchema<T>;
+  optional(): HiddenCapable<z.ZodOptional<T>>;
+  nullable(): HiddenCapable<z.ZodNullable<T>>;
+  nullish(): HiddenCapable<z.ZodOptional<z.ZodNullable<T>>>;
+};
+/** Create a MongoDB ObjectId schema. */
+declare const objectId: () => HiddenCapable<z.ZodInstanceOf<ObjectId$1>>;
+//#endregion
 //#region src/schema/schema.d.ts
 /** Built-in persistence behavior applied by a schema. */
 interface SchemaOptions {
   readonly timestamps?: boolean;
   readonly softdelete?: boolean;
+  /** Hide Mongorm-managed fields from default query results. */
+  readonly hideManaged?: boolean;
 }
 type IndexFieldMap<Shape extends SchemaShape> = Record<Extract<keyof Shape, string>, IndexDirection>;
 /** A non-empty, autocomplete-friendly MongoDB index key definition. */
@@ -255,14 +282,15 @@ type SchemaIndexNames<Indexes extends readonly SchemaIndex<any>[]> = Extract<Ind
     readonly name?: infer Name;
   };
 } ? Name : never : never, string>;
-type TimestampShape = {
-  createdAt: z.ZodDefault<z.ZodDate>;
-  updatedAt: z.ZodDefault<z.ZodDate>;
+type ManagedSchema<T extends z.ZodType, Options extends SchemaOptions> = Options['hideManaged'] extends true ? HiddenSchema<T> : T;
+type TimestampShape<Options extends SchemaOptions> = {
+  createdAt: ManagedSchema<z.ZodDefault<z.ZodDate>, Options>;
+  updatedAt: ManagedSchema<z.ZodDefault<z.ZodDate>, Options>;
 };
-type SoftDeleteShape = {
-  deletedAt: z.ZodDefault<z.ZodNullable<z.ZodDate>>;
+type SoftDeleteShape<Options extends SchemaOptions> = {
+  deletedAt: ManagedSchema<z.ZodDefault<z.ZodNullable<z.ZodDate>>, Options>;
 };
-type ManagedShape<Options extends SchemaOptions> = (Options['timestamps'] extends true ? TimestampShape : {}) & (Options['softdelete'] extends true ? SoftDeleteShape : {});
+type ManagedShape<Options extends SchemaOptions> = (Options['timestamps'] extends true ? TimestampShape<Options> : {}) & (Options['softdelete'] extends true ? SoftDeleteShape<Options> : {});
 type ManagedField<Options extends SchemaOptions> = (Options['timestamps'] extends true ? 'createdAt' | 'updatedAt' : never) | (Options['softdelete'] extends true ? 'deletedAt' : never);
 type SoftDeleteEnabled<Options extends SchemaOptions> = Options['softdelete'] extends true ? true : false;
 export declare const hasSoftDelete: (options: SchemaOptions) => boolean;
@@ -292,6 +320,7 @@ export declare class Schema<Shape extends SchemaShape, Relations extends SchemaR
   constructor(shape: Shape, relations?: Relations, scopeMap?: Scopes, optionsConfig?: Options, indexDefinitions?: Indexes);
   /** Enable managed timestamps and/or soft deletion for this schema. */
   options<const Enabled extends SchemaOptions>(options: Enabled): Schema<Shape & ManagedShape<Enabled>, Relations, Scopes, Enabled, Indexes>;
+  private managedField;
   /** Declare MongoDB indexes for explicit synchronization with the database. */
   indexes<const Definitions extends readonly SchemaIndex<Shape>[]>(definitions: readonly SchemaIndex<Shape>[] & ValidateIndexDefinitions<Shape, Definitions>): Schema<Shape, Relations, Scopes, Options, Definitions>;
   /** Add one or more one-way relations without requiring circular schema declarations. */
@@ -374,29 +403,6 @@ type SchemaRegistryBuilder<Registry extends Record<string, SchemaLike>> = Regist
 };
 declare const createSchemaRegistry: <const Registry extends Record<string, SchemaLike>>(registry: Registry) => SchemaRegistryBuilder<Registry>;
 //#endregion
-//#region src/schema/scalars.d.ts
-declare module 'zod' {
-  interface ZodType {
-    hidden(): this & {
-      readonly __hidden: true;
-    };
-  }
-}
-/** A schema field that can be marked as hidden from default query results. */
-type HiddenCapable<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T>;
-/** A schema field marked as hidden from default query results. */
-type HiddenSchema<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T> & {
-  readonly __hidden: true;
-};
-type HiddenMethods<T extends z.ZodType> = {
-  hidden(): HiddenSchema<T>;
-  optional(): HiddenCapable<z.ZodOptional<T>>;
-  nullable(): HiddenCapable<z.ZodNullable<T>>;
-  nullish(): HiddenCapable<z.ZodOptional<z.ZodNullable<T>>>;
-};
-/** Create a MongoDB ObjectId schema. */
-declare const objectId: () => HiddenCapable<z.ZodInstanceOf<ObjectId$1>>;
-//#endregion
 //#region src/api.d.ts
 type ZodConstructorKey = { [Key in keyof typeof z]: Key extends string ? Key extends Lowercase<Key> ? (typeof z)[Key] extends ((...args: any[]) => any) ? Key : never : never : never; }[keyof typeof z];
 type ZodConstructors = Pick<typeof z, ZodConstructorKey>;

package/dist/index.mjs

@@ -171,16 +171,19 @@ var Schema = class Schema {
 		if (options.softdelete && "deletedAt" in this.definition.shape) throw new Error("The deletedAt field is managed by Mongorm");
 		const managedShape = {
 			...options.timestamps ? {
-				createdAt: z.date().default(() => /* @__PURE__ */ new Date()),
-				updatedAt: z.date().default(() => /* @__PURE__ */ new Date())
+				createdAt: this.managedField(z.date().default(() => /* @__PURE__ */ new Date()), options),
+				updatedAt: this.managedField(z.date().default(() => /* @__PURE__ */ new Date()), options)
 			} : {},
-			...options.softdelete ? { deletedAt: z.date().nullable().default(null) } : {}
+			...options.softdelete ? { deletedAt: this.managedField(z.date().nullable().default(null), options) } : {}
 		};
 		return new Schema({
 			...this.definition.shape,
 			...managedShape
 		}, this.relationMap, this.scopeMap, options, this.indexDefinitions);
 	}
+	managedField(field, options) {
+		return options.hideManaged ? withHidden(field).hidden() : field;
+	}
 	/** Declare MongoDB indexes for explicit synchronization with the database. */
 	indexes(definitions) {
 		if (definitions.some(({ fields }) => Object.keys(fields).length === 0)) throw new Error("Index definitions must include at least one field");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mongorm/orm",
-  "version": "0.1.1-beta.3",
+  "version": "0.1.1-beta.4",
   "description": "A TypeScript-first MongoDB ORM for applications that want strong types without hiding MongoDB",
   "keywords": [
     "mongodb",