@mongorm/orm 0.1.0

package/src/relations/definitions.ts

@@ -0,0 +1,136 @@
+import { ObjectId } from 'mongodb';
+import { z } from 'zod';
+
+import type { SchemaShape } from '../schema/contracts.js';
+
+/** A schema-like target resolved lazily to support circular module imports. */
+export type SchemaLike = import('../schema/schema.js').Schema<SchemaShape, any, any, any>;
+
+/** Metadata attached to a forward relation field. */
+export interface RefDefinition<Target extends SchemaLike = SchemaLike> {
+  /** Resolve the related schema after module initialization completes. */
+  resolve: () => Target;
+}
+
+/** Metadata for a one-way relation between two MongoDB schemas. */
+export interface SchemaRelation<
+  Target extends SchemaLike = SchemaLike,
+  LocalField extends string = string,
+  ForeignField extends string = string,
+> {
+  readonly resolve: () => Target;
+  readonly localField: LocalField;
+  readonly foreignField: ForeignField;
+}
+
+/** Relation metadata attached to a schema. */
+export type SchemaRelationMap = Record<string, SchemaRelation>;
+
+/** A relation target declaration accepted by Schema.relations(). */
+export type RelationInput<Target extends SchemaLike = SchemaLike> =
+  | (() => Target)
+  | {
+      target: () => Target;
+      foreignField?: string;
+    };
+
+/** Extract a relation target from a relation declaration. */
+export type RelationInputTarget<Input> = Input extends () => infer Target
+  ? Target
+  : Input extends { target: () => infer Target }
+    ? Target
+    : never;
+
+/** A string identifier field carrying a typed relation target. */
+export type RefField<Target extends SchemaLike = SchemaLike> = z.ZodType<ObjectId> & {
+  readonly __ref?: RefDefinition<Target>;
+  optional(): OptionalRefField<Target>;
+  nullable(): NullableRefField<Target>;
+  nullish(): NullishRefField<Target>;
+};
+
+/** An optional relation field that retains its target metadata. */
+export type OptionalRefField<Target extends SchemaLike = SchemaLike> = z.ZodOptional<
+  RefField<Target>
+> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+
+/** A nullable relation field that retains its target metadata. */
+export type NullableRefField<Target extends SchemaLike = SchemaLike> = z.ZodNullable<
+  RefField<Target>
+> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+
+/** An optional and nullable relation field that retains its target metadata. */
+export type NullishRefField<Target extends SchemaLike = SchemaLike> = z.ZodOptional<
+  NullableRefField<Target>
+> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+
+type RelationDefinition<Field> = Field extends { readonly __ref?: infer Definition }
+  ? NonNullable<Definition>
+  : Field extends z.ZodOptional<infer Inner>
+    ? RelationDefinition<Inner>
+    : Field extends z.ZodNullable<infer Inner>
+      ? RelationDefinition<Inner>
+      : never;
+
+/** The relation metadata inferred from a schema shape. */
+export type RelationMap<Shape extends SchemaShape> = {
+  [
+    Key in keyof Shape as RelationDefinition<Shape[Key]> extends never ? never : Key
+  ]: RelationDefinition<Shape[Key]>;
+};
+
+/** Create a string ID field linked to a lazily resolved target schema. */
+export const createRef = <Target extends SchemaLike>(resolve: () => Target): RefField<Target> => {
+  const field = z.instanceof(ObjectId) as RefField<Target>;
+  const createOptional = field.optional.bind(field);
+  const createNullable = field.nullable.bind(field);
+  const createNullish = field.nullish.bind(field);
+  Object.defineProperty(field, '__ref', {
+    configurable: false,
+    enumerable: false,
+    value: { resolve },
+  });
+  Object.defineProperty(field, 'optional', {
+    configurable: false,
+    enumerable: false,
+    value: () => attachRef(createOptional(), resolve) as OptionalRefField<Target>,
+  });
+  Object.defineProperty(field, 'nullable', {
+    configurable: false,
+    enumerable: false,
+    value: () => attachRef(createNullable(), resolve),
+  });
+  Object.defineProperty(field, 'nullish', {
+    configurable: false,
+    enumerable: false,
+    value: () => attachRef(createNullish(), resolve),
+  });
+  return field;
+};
+
+const attachRef = <Field extends z.ZodType, Target extends SchemaLike>(
+  field: Field,
+  resolve: () => Target,
+): Field & { readonly __ref?: RefDefinition<Target> } => {
+  Object.defineProperty(field, '__ref', {
+    configurable: false,
+    enumerable: false,
+    value: { resolve },
+  });
+  return field as Field & { readonly __ref?: RefDefinition<Target> };
+};
+
+/** Collect relation metadata from a schema shape without evaluating targets. */
+export const collectRefs = <Shape extends SchemaShape>(shape: Shape): RelationMap<Shape> => {
+  return Object.fromEntries(
+    Object.entries(shape)
+      .filter(([, field]) => '__ref' in field)
+      .map(([name, field]) => [name, (field as RefField).__ref]),
+  ) as unknown as RelationMap<Shape>;
+};

package/src/relations/registry.ts

@@ -0,0 +1,144 @@
+import type { ObjectId } from 'mongodb';
+
+import type { PopulateSpecs } from '../query/query.js';
+import type { SchemaShape } from '../schema/contracts.js';
+import type { InferShape } from '../schema/inference.js';
+import type { Schema, ScopeDefinitions } from '../schema/schema.js';
+import type { SchemaRelation, SchemaRelationMap, SchemaLike } from './definitions.js';
+
+type ObjectIdKeys<Shape extends SchemaShape> = {
+  [Key in keyof InferShape<Schema<Shape>>]-?: NonNullable<
+    InferShape<Schema<Shape>>[Key]
+  > extends ObjectId
+    ? Key
+    : never;
+}[keyof InferShape<Schema<Shape>>];
+
+export type RelationDefinitions<Registry extends Record<string, SchemaLike>> = {
+  [Name in keyof Registry]?: Registry[Name] extends Schema<infer Shape, any, any, any>
+    ? Partial<Record<Extract<ObjectIdKeys<Shape>, string>, Extract<keyof Registry, string>>>
+    : never;
+};
+
+type EnrichedSchema<
+  Registry extends Record<string, SchemaLike>,
+  AllDefinitions extends RelationDefinitions<Registry>,
+  Name,
+> = Name extends keyof Registry
+  ? Registry[Name] extends Schema<infer Shape, infer Relations, infer Scopes, infer Options>
+    ? Schema<
+        Shape,
+        Relations & RelationsFor<Registry, AllDefinitions, NonNullable<AllDefinitions[Name]>>,
+        Scopes,
+        Options
+      >
+    : never
+  : never;
+
+type RelationsFor<
+  Registry extends Record<string, SchemaLike>,
+  AllDefinitions extends RelationDefinitions<Registry>,
+  Definitions,
+> = {
+  [Field in keyof Definitions & string]: Definitions[Field] extends keyof Registry
+    ? SchemaRelation<EnrichedSchema<Registry, AllDefinitions, Definitions[Field]>, Field, '_id'>
+    : never;
+};
+
+type RegistryWithRelations<
+  Registry extends Record<string, SchemaLike>,
+  Definitions extends RelationDefinitions<Registry>,
+> = {
+  [Name in keyof Registry]: Registry[Name] extends Schema<
+    infer Shape,
+    infer Relations,
+    infer Scopes,
+    infer Options
+  >
+    ? Schema<
+        Shape,
+        Relations & RelationsFor<Registry, Definitions, NonNullable<Definitions[Name]>>,
+        Scopes,
+        Options
+      >
+    : Registry[Name];
+};
+
+type RelationMapOf<Value> = Value extends Schema<any, infer Relations, any, any> ? Relations : {};
+
+export type ScopeDefinitionsBySchema<Registry extends Record<string, SchemaLike>> = {
+  [Name in keyof Registry]?: Record<string, PopulateSpecs<RelationMapOf<Registry[Name]>>>;
+};
+
+type RegistryWithScopes<
+  Registry extends Record<string, SchemaLike>,
+  Definitions extends ScopeDefinitionsBySchema<Registry>,
+> = {
+  [Name in keyof Registry]: Registry[Name] extends Schema<
+    infer Shape,
+    infer Relations,
+    infer Scopes,
+    infer Options
+  >
+    ? Schema<
+        Shape,
+        Relations,
+        Scopes & (Definitions[Name] extends ScopeDefinitions ? Definitions[Name] : {}),
+        Options
+      >
+    : Registry[Name];
+};
+
+export type SchemaRegistryBuilder<Registry extends Record<string, SchemaLike>> = Registry & {
+  readonly __registry?: Registry;
+  defineRelations<const Definitions extends RelationDefinitions<Registry>>(
+    definitions: Definitions,
+  ): SchemaRegistryBuilder<RegistryWithRelations<Registry, Definitions>>;
+  defineScopes<const Definitions extends ScopeDefinitionsBySchema<Registry>>(
+    definitions: Definitions,
+  ): SchemaRegistryBuilder<RegistryWithScopes<Registry, Definitions>>;
+};
+
+const attachMethods = <Registry extends Record<string, SchemaLike>>(
+  registry: Registry,
+): SchemaRegistryBuilder<Registry> => {
+  const defineRelations = (definitions: RelationDefinitions<Registry>) => {
+    for (const [name, relations] of Object.entries(definitions)) {
+      const targetSchema = registry[name];
+      if (!targetSchema) throw new Error(`Unknown schema "${name}" in relation definitions`);
+      for (const [field, targetName] of Object.entries(relations ?? {})) {
+        const target = registry[targetName as string];
+        if (!target) throw new Error(`Unknown relation target "${targetName}"`);
+        if (!(field in targetSchema.definition.shape)) {
+          throw new Error(`Unknown relation field "${name}.${field}"`);
+        }
+        (targetSchema.relationMap as SchemaRelationMap)[field] = {
+          resolve: () => target,
+          localField: field,
+          foreignField: '_id',
+        };
+      }
+    }
+    return attachMethods(registry);
+  };
+
+  const defineScopes = (definitions: ScopeDefinitionsBySchema<Registry>) => {
+    for (const [name, scopes] of Object.entries(definitions)) {
+      const targetSchema = registry[name];
+      if (!targetSchema) throw new Error(`Unknown schema "${name}" in scope definitions`);
+      Object.assign(targetSchema.scopeMap, scopes);
+    }
+    return attachMethods(registry);
+  };
+
+  Object.defineProperties(registry, {
+    __registry: { configurable: false, enumerable: false, value: registry },
+    defineRelations: { configurable: true, enumerable: false, value: defineRelations },
+    defineScopes: { configurable: true, enumerable: false, value: defineScopes },
+  });
+  return registry as SchemaRegistryBuilder<Registry>;
+};
+
+export const createSchemaRegistry = <const Registry extends Record<string, SchemaLike>>(
+  registry: Registry,
+): SchemaRegistryBuilder<Registry> => attachMethods(registry);

package/src/schema/contracts.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+
+/** A Zod object shape used as the source of truth for a model. */
+export type SchemaShape = z.ZodRawShape;
+
+/** The runtime Zod object generated from a schema shape. */
+export type SchemaDefinition<Shape extends SchemaShape> = z.ZodObject<Shape>;

package/src/schema/index.ts

@@ -0,0 +1,22 @@
+export { Schema } from './schema.js';
+export { hasSoftDelete } from './schema.js';
+export type {
+  ManagedField,
+  SchemaIndex,
+  SchemaIndexFields,
+  SchemaOptions,
+  ScopeDefinitions,
+  SoftDeleteEnabled,
+} from './schema.js';
+export type { Infer, InferInput, InferShape } from './inference.js';
+export type { SchemaDefinition, SchemaShape } from './contracts.js';
+export type {
+  RefDefinition,
+  RefField,
+  RelationInput,
+  RelationInputTarget,
+  RelationMap,
+  SchemaLike,
+  SchemaRelation,
+  SchemaRelationMap,
+} from '../relations/definitions.js';

package/src/schema/inference.ts

@@ -0,0 +1,17 @@
+import type { ObjectId } from 'mongodb';
+import type { z } from 'zod';
+
+/** The raw parsed shape produced by a schema before persistence fields are added. */
+export type InferShape<T> = T extends { definition: infer Definition extends z.ZodType }
+  ? z.infer<Definition>
+  : never;
+
+/** The input type accepted by a schema before Zod defaults are applied. */
+export type InferInput<T> = T extends { definition: infer Definition extends z.ZodType }
+  ? z.input<Definition>
+  : never;
+
+/** The persisted document type inferred from a schema. */
+export type Infer<T> = InferShape<T> & {
+  _id: ObjectId;
+};

package/src/schema/scalars.ts

@@ -0,0 +1,110 @@
+import { ObjectId } from 'mongodb';
+import { z } from 'zod';
+
+declare module 'zod' {
+  interface ZodType {
+    hidden(): this & { readonly __hidden: true };
+  }
+}
+
+if (!Object.prototype.hasOwnProperty.call(z.ZodType.prototype, 'hidden')) {
+  Object.defineProperty(z.ZodType.prototype, 'hidden', {
+    configurable: false,
+    enumerable: false,
+    value(this: z.ZodType) {
+      Object.defineProperty(this, '__hidden', {
+        configurable: false,
+        enumerable: false,
+        value: true,
+      });
+      return this;
+    },
+  });
+}
+
+/** A schema field that can be marked as hidden from default query results. */
+export type HiddenCapable<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> &
+  HiddenMethods<T>;
+
+/** A schema field marked as hidden from default query results. */
+export 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>>>;
+};
+
+export const withHidden = <T extends z.ZodType>(schema: T): HiddenCapable<T> => {
+  return new Proxy(schema, {
+    get(target, property, receiver) {
+      if (property === 'hidden') {
+        return () => {
+          Object.defineProperty(target, '__hidden', {
+            configurable: false,
+            enumerable: false,
+            value: true,
+          });
+          return receiver;
+        };
+      }
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== 'function') return value;
+      return (...args: unknown[]) => {
+        const result = value.apply(target, args);
+        return result instanceof z.ZodType ? withHidden(result) : result;
+      };
+    },
+  }) as unknown as HiddenCapable<T>;
+};
+
+/** Wrap native Zod constructors so returned schemas support `.hidden()`. */
+export const withZodNamespace = <T extends object>(namespace: T): T =>
+  new Proxy(namespace, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (
+        typeof value !== 'function' ||
+        String(property)[0] !== String(property)[0].toLowerCase()
+      ) {
+        return value;
+      }
+      return (...args: unknown[]) => {
+        const result = value.apply(target, args);
+        return result instanceof z.ZodType ? withHidden(result) : result;
+      };
+    },
+  });
+
+/** Create a string schema. */
+export const string = () => withHidden(z.string());
+
+/** Create an email schema. */
+export const email = () => withHidden(z.email());
+
+/** Create a URL schema. */
+export const url = () => withHidden(z.url());
+
+/** Create a number schema. */
+export const number = () => withHidden(z.number());
+
+/** Create a boolean schema. */
+export const boolean = () => withHidden(z.boolean());
+
+/** Create a date schema. */
+export const date = () => withHidden(z.date());
+
+/** Create a MongoDB ObjectId schema. */
+export const objectId = () => withHidden(z.instanceof(ObjectId));
+
+/** Create a nested object schema. */
+export const object = <const Shape extends z.ZodRawShape>(shape: Shape) =>
+  withHidden(z.object(shape));
+
+/** Create a string enum schema while preserving literal members. */
+export const enumeration = <const Values extends readonly [string, ...string[]]>(values: Values) =>
+  withHidden(z.enum(values));

package/src/schema/schema.ts

@@ -0,0 +1,234 @@
+import type { IndexDescription, IndexDirection, ObjectId } from 'mongodb';
+import { z } from 'zod';
+
+import type { PopulateSpecs } from '../query/query.js';
+import { collectRefs } from '../relations/definitions.js';
+import type {
+  RelationInput,
+  RelationInputTarget,
+  RelationMap,
+  SchemaRelation,
+  SchemaRelationMap,
+  SchemaLike,
+} from '../relations/definitions.js';
+import type { SchemaDefinition, SchemaShape } from './contracts.js';
+import type { InferShape } from './inference.js';
+
+/** Built-in persistence behavior applied by a schema. */
+export interface SchemaOptions {
+  readonly timestamps?: boolean;
+  readonly softdelete?: boolean;
+}
+
+export type SchemaIndexFields<Shape extends SchemaShape> = Partial<
+  Record<Extract<keyof Shape, string>, IndexDirection>
+>;
+
+export type SchemaIndex<Shape extends SchemaShape> = {
+  readonly fields: SchemaIndexFields<Shape>;
+  readonly options?: Omit<IndexDescription, 'key'>;
+};
+
+type TimestampShape = {
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+};
+
+type SoftDeleteShape = {
+  deletedAt: z.ZodDefault<z.ZodNullable<z.ZodDate>>;
+};
+
+type ManagedShape<Options extends SchemaOptions> = (Options['timestamps'] extends true
+  ? TimestampShape
+  : {}) &
+  (Options['softdelete'] extends true ? SoftDeleteShape : {});
+
+export type ManagedField<Options extends SchemaOptions> =
+  | (Options['timestamps'] extends true ? 'createdAt' | 'updatedAt' : never)
+  | (Options['softdelete'] extends true ? 'deletedAt' : never);
+
+export type SoftDeleteEnabled<Options extends SchemaOptions> = Options['softdelete'] extends true
+  ? true
+  : false;
+
+export const hasSoftDelete = (options: SchemaOptions): boolean => options.softdelete === true;
+
+type ObjectIdFieldKeys<Shape extends SchemaShape> = {
+  [Key in keyof InferShape<Schema<Shape>>]-?: NonNullable<
+    InferShape<Schema<Shape>>[Key]
+  > extends ObjectId
+    ? Key
+    : never;
+}[keyof InferShape<Schema<Shape>>];
+
+export type ScopeDefinitions = Record<string, readonly object[]>;
+
+/** A typed, runtime-validated schema definition. */
+export class Schema<
+  Shape extends SchemaShape,
+  Relations extends SchemaRelationMap = {},
+  Scopes extends ScopeDefinitions = {},
+  Options extends SchemaOptions = {},
+> {
+  /** The underlying Zod object for advanced validation use cases. */
+  readonly definition: SchemaDefinition<Shape>;
+
+  /** The lazily resolved relation metadata declared by this schema. */
+  readonly refs: RelationMap<Shape>;
+
+  /** One-way relation metadata declared for this schema. */
+  readonly relationMap: Relations;
+
+  /** Named population scopes declared for this schema. */
+  scopeMap: Scopes;
+
+  /** Field names excluded from default query results. */
+  readonly hiddenFields: readonly (keyof Shape & string)[];
+
+  /** Field names declared by this schema. */
+  readonly fields: readonly (keyof Shape & string)[];
+
+  /** Persistence behavior enabled for this schema. */
+  readonly optionsConfig: Options;
+
+  /** MongoDB indexes declared for this schema. */
+  indexDefinitions: readonly SchemaIndex<Shape>[];
+
+  /** Preserve schema options through registry type transformations. */
+  declare readonly __options: Options;
+
+  /** Construct a schema from a Zod object shape. */
+  constructor(
+    shape: Shape,
+    relations = {} as Relations,
+    scopeMap = {} as Scopes,
+    optionsConfig = {} as Options,
+    indexDefinitions = [] as readonly SchemaIndex<Shape>[],
+  ) {
+    this.definition = z.object(shape);
+    this.refs = collectRefs(shape);
+    this.relationMap = relations;
+    this.scopeMap = scopeMap;
+    this.fields = Object.keys(shape) as (keyof Shape & string)[];
+    this.hiddenFields = this.fields.filter((field) => '__hidden' in shape[field]);
+    this.optionsConfig = optionsConfig;
+    this.indexDefinitions = indexDefinitions;
+  }
+
+  /** Enable managed timestamps and/or soft deletion for this schema. */
+  options<const Enabled extends SchemaOptions>(
+    options: Enabled,
+  ): Schema<Shape & ManagedShape<Enabled>, Relations, Scopes, Enabled> {
+    if (this.optionsConfig && Object.keys(this.optionsConfig).length > 0) {
+      throw new Error('Schema options can only be configured once');
+    }
+    if (
+      options.timestamps &&
+      ('createdAt' in this.definition.shape || 'updatedAt' in this.definition.shape)
+    ) {
+      throw new Error('Timestamp fields createdAt and updatedAt are managed by Mongorm');
+    }
+    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(() => new Date()),
+            updatedAt: z.date().default(() => new Date()),
+          }
+        : {}),
+      ...(options.softdelete ? { deletedAt: z.date().nullable().default(null) } : {}),
+    } as ManagedShape<Enabled>;
+    const next = new Schema(
+      { ...this.definition.shape, ...managedShape } as Shape & ManagedShape<Enabled>,
+      this.relationMap,
+      this.scopeMap,
+      options,
+      this.indexDefinitions,
+    );
+    return next as unknown as Schema<Shape & ManagedShape<Enabled>, Relations, Scopes, Enabled>;
+  }
+
+  /** Declare MongoDB indexes for explicit synchronization with the database. */
+  indexes<const Definitions extends readonly SchemaIndex<Shape>[]>(definitions: Definitions): this {
+    if (definitions.some(({ fields }) => Object.keys(fields).length === 0)) {
+      throw new Error('Index definitions must include at least one field');
+    }
+    this.indexDefinitions = definitions;
+    return this;
+  }
+
+  /** Add one or more one-way relations without requiring circular schema declarations. */
+  relations<
+    const Definitions extends Partial<
+      Record<Extract<ObjectIdFieldKeys<Shape>, string>, RelationInput>
+    >,
+  >(
+    definitions: Definitions &
+      Record<Exclude<keyof Definitions, Extract<ObjectIdFieldKeys<Shape>, string>>, never>,
+  ): Schema<
+    Shape,
+    Relations & {
+      [Name in keyof Definitions]: SchemaRelation<
+        RelationInputTarget<NonNullable<Definitions[Name]>>,
+        Extract<Name, string>,
+        NonNullable<Definitions[Name]> extends { foreignField: infer Foreign extends string }
+          ? Foreign
+          : '_id'
+      >;
+    },
+    Scopes,
+    Options
+  > {
+    for (const [name, input] of Object.entries(definitions)) {
+      const definition = (typeof input === 'function' ? { target: input } : input) as {
+        target: () => SchemaLike;
+        foreignField?: string;
+      };
+      (this.relationMap as SchemaRelationMap)[name] = {
+        resolve: definition.target,
+        localField: name,
+        foreignField: definition.foreignField ?? '_id',
+      };
+    }
+    return this as unknown as Schema<
+      Shape,
+      Relations & {
+        [Name in keyof Definitions]: SchemaRelation<
+          RelationInputTarget<NonNullable<Definitions[Name]>>,
+          Extract<Name, string>,
+          NonNullable<Definitions[Name]> extends { foreignField: infer Foreign extends string }
+            ? Foreign
+            : '_id'
+        >;
+      },
+      Scopes,
+      Options
+    >;
+  }
+
+  /** Declare named, reusable population scopes. */
+  scopes<const Definitions extends Record<string, PopulateSpecs<Relations>>>(
+    definitions: Definitions,
+  ): Schema<Shape, Relations, Definitions, Options> {
+    this.scopeMap = definitions as unknown as Scopes;
+    return this as unknown as Schema<Shape, Relations, Definitions, Options>;
+  }
+
+  /** Parse unknown input and return the inferred document type. */
+  parse(input: unknown): InferShape<this> {
+    return this.definition.parse(input) as InferShape<this>;
+  }
+
+  /** Parse a partial document for update operations. */
+  parsePartial(input: unknown): Partial<InferShape<this>> {
+    return this.definition.partial().parse(input) as Partial<InferShape<this>>;
+  }
+
+  /** Parse unknown input without throwing on validation failure. */
+  safeParse(input: unknown): ReturnType<typeof this.definition.safeParse> {
+    return this.definition.safeParse(input);
+  }
+}