@prisma-next/mongo-orm 0.11.0 → 0.12.0

package/src/field-accessor.ts

@@ -1,10 +1,15 @@
-import type { ContractField, ContractValueObject } from '@prisma-next/contract/types';
+import type {
+  ContractField,
+  ContractValueObject,
+  ContractValueObjectsMap,
+} from '@prisma-next/contract/types';
 import type {
   ExtractMongoCodecTypes,
   ExtractMongoFieldOutputTypes,
   InferModelRow,
   MongoContract,
   MongoContractWithTypeMaps,
+  MongoModelsMap,
   MongoTypeMaps,
 } from '@prisma-next/mongo-contract';
 import type { MongoValue } from '@prisma-next/mongo-value';
@@ -32,46 +37,85 @@ export interface FieldOperation {
 
 type ScalarFieldKeys<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
-  [K in keyof TContract['models'][ModelName]['fields'] &
-    string]: TContract['models'][ModelName]['fields'][K] extends {
+  [K in keyof MongoModelsMap<TContract>[ModelName]['fields'] &
+    string]: MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
     readonly type: { readonly kind: 'scalar' };
   }
     ? K
     : never;
-}[keyof TContract['models'][ModelName]['fields'] & string];
+}[keyof MongoModelsMap<TContract>[ModelName]['fields'] & string];
 
 type ValueObjectFieldKeys<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
-  [K in keyof TContract['models'][ModelName]['fields'] &
-    string]: TContract['models'][ModelName]['fields'][K] extends {
+  [K in keyof MongoModelsMap<TContract>[ModelName]['fields'] &
+    string]: MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
     readonly type: { readonly kind: 'valueObject'; readonly name: string };
   }
     ? K
     : never;
-}[keyof TContract['models'][ModelName]['fields'] & string];
+}[keyof MongoModelsMap<TContract>[ModelName]['fields'] & string];
 
 type ResolvedModelRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+  TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
 > = string extends keyof ExtractMongoFieldOutputTypes<TContract>
-  ? InferModelRow<TContract, ModelName>
+  ? InferModelRow<TContract, ModelName, MongoModelsMap<TContract>[ModelName]['fields'], TCodecTypes>
   : ModelName extends keyof ExtractMongoFieldOutputTypes<TContract>
     ? {
         -readonly [K in keyof ExtractMongoFieldOutputTypes<TContract>[ModelName]]: ExtractMongoFieldOutputTypes<TContract>[ModelName][K];
       }
-    : InferModelRow<TContract, ModelName>;
+    : InferModelRow<
+        TContract,
+        ModelName,
+        MongoModelsMap<TContract>[ModelName]['fields'],
+        TCodecTypes
+      >;
 
 type ResolveFieldType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
-  K extends keyof TContract['models'][ModelName]['fields'] & string,
-> = K extends keyof ResolvedModelRow<TContract, ModelName>
-  ? ResolvedModelRow<TContract, ModelName>[K]
-  : unknown;
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+  K extends keyof MongoModelsMap<TContract>[ModelName]['fields'] & string,
+  TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
+> = MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
+  readonly type: {
+    readonly kind: 'scalar';
+    readonly codecId: infer CId extends string & keyof TCodecTypes;
+  };
+  readonly many: true;
+  readonly nullable: true;
+}
+  ? readonly TCodecTypes[CId]['output'][] | null
+  : MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
+        readonly type: {
+          readonly kind: 'scalar';
+          readonly codecId: infer CId extends string & keyof TCodecTypes;
+        };
+        readonly many: true;
+      }
+    ? readonly TCodecTypes[CId]['output'][]
+    : MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
+          readonly type: {
+            readonly kind: 'scalar';
+            readonly codecId: infer CId extends string & keyof TCodecTypes;
+          };
+          readonly nullable: true;
+        }
+      ? TCodecTypes[CId]['output'] | null
+      : MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
+            readonly type: {
+              readonly kind: 'scalar';
+              readonly codecId: infer CId extends string & keyof TCodecTypes;
+            };
+          }
+        ? TCodecTypes[CId]['output']
+        : K extends keyof ResolvedModelRow<TContract, ModelName, TCodecTypes>
+          ? ResolvedModelRow<TContract, ModelName, TCodecTypes>[K]
+          : unknown;
 
 type NumericOps = {
   inc(value: number): FieldOperation;
@@ -87,13 +131,24 @@ export type FieldExpression<T = unknown> = {
   pop(end: 1 | -1): FieldOperation;
 } & (T extends number ? NumericOps : unknown);
 
-type HasValueObjects = { readonly valueObjects?: Record<string, ContractValueObject> };
+type HasValueObjects = MongoContract;
 
-type VOFields<TContract extends HasValueObjects, VOName extends string> = TContract extends {
-  readonly valueObjects: infer VOs extends Record<string, ContractValueObject>;
-}
-  ? VOName extends keyof VOs
-    ? VOs[VOName]['fields']
+type MergedContractValueObjects<TContract extends HasValueObjects> =
+  ContractValueObjectsMap<TContract> &
+    (TContract extends { readonly valueObjects?: infer VOs }
+      ? VOs extends Record<string, ContractValueObject>
+        ? VOs
+        : Record<string, never>
+      : Record<string, never>);
+
+type VOFields<
+  TContract extends HasValueObjects,
+  VOName extends string,
+> = VOName extends keyof MergedContractValueObjects<TContract>
+  ? MergedContractValueObjects<TContract>[VOName] extends {
+      readonly fields: infer F extends Record<string, ContractField>;
+    }
+    ? F
     : never
   : never;
 
@@ -127,12 +182,12 @@ type VODotPaths<
 
 export type DotPath<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
   [K in ValueObjectFieldKeys<
     TContract,
     ModelName
-  >]: TContract['models'][ModelName]['fields'][K] extends {
+  >]: MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
     readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
   }
     ? VODotPaths<TContract, VOFields<TContract, N>, `${K}.`>
@@ -165,12 +220,12 @@ type ResolveDotPathInFields<
 
 export type ResolveDotPathType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   Path extends string,
   TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
 > = Path extends `${infer Head}.${infer Rest}`
-  ? Head extends keyof TContract['models'][ModelName]['fields'] & string
-    ? TContract['models'][ModelName]['fields'][Head] extends {
+  ? Head extends keyof MongoModelsMap<TContract>[ModelName]['fields'] & string
+    ? MongoModelsMap<TContract>[ModelName]['fields'][Head] extends {
         readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
       }
       ? ResolveDotPathInFields<TContract, VOFields<TContract, N>, Rest, TCodecTypes>
@@ -180,18 +235,19 @@ export type ResolveDotPathType<
 
 export type FieldAccessor<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+  TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
 > = {
   readonly [K in ScalarFieldKeys<TContract, ModelName>]: FieldExpression<
-    ResolveFieldType<TContract, ModelName, K>
+    ResolveFieldType<TContract, ModelName, K, TCodecTypes>
   >;
 } & {
   readonly [K in ValueObjectFieldKeys<TContract, ModelName>]: FieldExpression<
-    ResolveFieldType<TContract, ModelName, K>
+    ResolveFieldType<TContract, ModelName, K, TCodecTypes>
   >;
 } & (<P extends DotPath<TContract, ModelName>>(
     path: P,
-  ) => FieldExpression<ResolveDotPathType<TContract, ModelName, P>>);
+  ) => FieldExpression<ResolveDotPathType<TContract, ModelName, P, TCodecTypes>>);
 
 // ── Runtime implementation ───────────────────────────────────────────────────
 
@@ -236,9 +292,10 @@ function createFieldExpression(fieldPath: string): RuntimeFieldExpression {
 
 export function createFieldAccessor<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
->(): FieldAccessor<TContract, ModelName> {
-  return new Proxy((() => {}) as unknown as FieldAccessor<TContract, ModelName>, {
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+  TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
+>(): FieldAccessor<TContract, ModelName, TCodecTypes> {
+  return new Proxy((() => {}) as unknown as FieldAccessor<TContract, ModelName, TCodecTypes>, {
     get(_target, prop: string): RuntimeFieldExpression {
       return createFieldExpression(prop);
     },

package/src/mongo-orm.ts

@@ -2,7 +2,9 @@ import type {
   MongoContract,
   MongoContractWithTypeMaps,
   MongoTypeMaps,
+  RootModelName,
 } from '@prisma-next/mongo-contract';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { MongoCollection } from './collection';
 import { createMongoCollection } from './collection';
 import type { MongoQueryExecutor } from './executor';
@@ -15,10 +17,10 @@ export interface MongoOrmOptions<TContract extends MongoContract> {
 export type MongoOrmClient<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
 > = {
-  readonly [K in keyof TContract['roots']]: TContract['roots'][K] extends string &
-    keyof TContract['models']
-    ? MongoCollection<TContract, TContract['roots'][K]>
-    : never;
+  readonly [K in keyof TContract['roots'] & string]: MongoCollection<
+    TContract,
+    RootModelName<TContract, K>
+  >;
 };
 
 export function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(
@@ -27,10 +29,13 @@ export function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContra
   const { contract, executor } = options;
   const client: Record<string, unknown> = {};
 
-  for (const [rootName, modelName] of Object.entries(contract.roots)) {
+  for (const [rootName, rootRef] of Object.entries(contract.roots)) {
     client[rootName] = createMongoCollection(
       contract,
-      modelName as string & keyof TContract['models'],
+      blindCast<
+        RootModelName<TContract, typeof rootName & keyof TContract['roots'] & string>,
+        'roots entries are CrossReferences; rootRef.model is a valid RootModelName for this contract'
+      >(rootRef.model),
       executor,
     );
   }

package/src/mongo-raw.ts

@@ -1,4 +1,4 @@
-import type { PlanMeta } from '@prisma-next/contract/types';
+import { contractModels, type PlanMeta } from '@prisma-next/contract/types';
 import type { MongoContract, MongoModelDefinition } from '@prisma-next/mongo-contract';
 import { createRawMongoCollection, type RawMongoCollection } from './raw-collection';
 
@@ -13,11 +13,12 @@ export function mongoRaw<TContract extends MongoContract>(options: {
 
   return {
     collection<K extends keyof TContract['roots'] & string>(rootName: K): RawMongoCollection {
-      const modelName = contract.roots[rootName] as string;
-      if (!Object.hasOwn(contract.models, modelName)) {
-        throw new Error(`Unknown model "${modelName}" for root "${rootName}"`);
+      const modelName = contract.roots[rootName]?.model;
+      const models = contractModels(contract);
+      if (!modelName || !Object.hasOwn(models, modelName)) {
+        throw new Error(`Unknown model "${modelName ?? ''}" for root "${rootName}"`);
       }
-      const model = contract.models[modelName] as MongoModelDefinition;
+      const model = models[modelName] as MongoModelDefinition;
       const collectionName = model.storage.collection ?? modelName;
 
       const meta: PlanMeta = {

package/src/types.ts

@@ -6,6 +6,7 @@ import type {
   InferModelRow,
   MongoContract,
   MongoContractWithTypeMaps,
+  MongoModelsMap,
   MongoTypeMaps,
 } from '@prisma-next/mongo-contract';
 
@@ -13,12 +14,12 @@ type Simplify<T> = T extends unknown ? { [K in keyof T]: T[K] } : never;
 
 type ModelRelations<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
-> = NonNullable<TContract['models'][ModelName]['relations']>;
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+> = NonNullable<MongoModelsMap<TContract>[ModelName]['relations']>;
 
 export type ReferenceRelationKeys<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
   [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
     TContract,
@@ -30,7 +31,7 @@ export type ReferenceRelationKeys<
 
 export type EmbedRelationKeys<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
   [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
     TContract,
@@ -42,7 +43,7 @@ export type EmbedRelationKeys<
 
 type ResolvedOutputRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = string extends keyof ExtractMongoFieldOutputTypes<TContract>
   ? InferModelRow<TContract, ModelName>
   : ModelName extends keyof ExtractMongoFieldOutputTypes<TContract>
@@ -53,7 +54,7 @@ type ResolvedOutputRow<
 
 type ResolvedInputRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = string extends keyof ExtractMongoFieldInputTypes<TContract>
   ? InferModelRow<TContract, ModelName>
   : ModelName extends keyof ExtractMongoFieldInputTypes<TContract>
@@ -62,24 +63,32 @@ type ResolvedInputRow<
       }
     : InferModelRow<TContract, ModelName>;
 
+type RelationTargetModel<TContract extends MongoContract, R> = R extends {
+  readonly to: { readonly model: infer M extends string & keyof MongoModelsMap<TContract> };
+}
+  ? M
+  : never;
+
 type EmbedRelationRowType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   RelKey extends keyof ModelRelations<TContract, ModelName>,
-> = ModelRelations<TContract, ModelName>[RelKey] extends {
-  readonly to: infer To extends string & keyof TContract['models'];
-  readonly cardinality: infer C;
-}
-  ? ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation
-    ? never
-    : C extends '1:N'
-      ? ResolvedOutputRow<TContract, To>[]
-      : ResolvedOutputRow<TContract, To>
+> = ModelRelations<TContract, ModelName>[RelKey] extends infer R
+  ? R extends { readonly cardinality: infer C }
+    ? ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation
+      ? never
+      : RelationTargetModel<TContract, R> extends infer To extends string &
+            keyof MongoModelsMap<TContract>
+        ? C extends '1:N'
+          ? ResolvedOutputRow<TContract, To>[]
+          : ResolvedOutputRow<TContract, To>
+        : never
+    : never
   : never;
 
 export type InferFullRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > =
   EmbedRelationKeys<TContract, ModelName> extends never
     ? ResolvedOutputRow<TContract, ModelName>
@@ -94,14 +103,14 @@ export type InferFullRow<
 
 type VariantRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
-> = TContract['models'][ModelName] extends {
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+> = MongoModelsMap<TContract>[ModelName] extends {
   readonly discriminator: { readonly field: infer DiscField extends string };
   readonly variants: infer V;
 }
   ? V extends Record<string, { readonly value: string }>
     ? {
-        [VK in keyof V]: VK extends string & keyof TContract['models']
+        [VK in keyof V]: VK extends string & keyof MongoModelsMap<TContract>
           ? Simplify<
               Omit<InferFullRow<TContract, ModelName>, DiscField> &
                 InferFullRow<TContract, VK> &
@@ -114,13 +123,13 @@ type VariantRow<
 
 export type InferRootRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = VariantRow<TContract, ModelName>;
 
 export type VariantNames<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
-> = TContract['models'][ModelName] extends {
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+> = MongoModelsMap<TContract>[ModelName] extends {
   readonly variants: infer V extends Record<string, unknown>;
 }
   ? keyof V & string
@@ -128,14 +137,14 @@ export type VariantNames<
 
 export type VariantModelRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   VariantName extends string,
-> = TContract['models'][ModelName] extends {
+> = MongoModelsMap<TContract>[ModelName] extends {
   readonly discriminator: { readonly field: infer DiscField extends string };
   readonly variants: infer V;
 }
   ? V extends Record<string, { readonly value: string }>
-    ? VariantName extends keyof V & string & keyof TContract['models']
+    ? VariantName extends keyof V & string & keyof MongoModelsMap<TContract>
       ? Simplify<
           Omit<InferFullRow<TContract, ModelName>, DiscField> &
             InferFullRow<TContract, VariantName> &
@@ -147,22 +156,24 @@ export type VariantModelRow<
 
 type IncludeRelationRowType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   RelKey extends keyof ModelRelations<TContract, ModelName>,
 > = ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation
-  ? ModelRelations<TContract, ModelName>[RelKey] extends {
-      readonly to: infer To extends string & keyof TContract['models'];
-      readonly cardinality: infer C;
-    }
-    ? C extends 'N:1' | '1:1'
-      ? InferFullRow<TContract, To> | null
-      : InferFullRow<TContract, To>[]
+  ? ModelRelations<TContract, ModelName>[RelKey] extends infer R
+    ? R extends { readonly cardinality: infer C }
+      ? RelationTargetModel<TContract, R> extends infer To extends string &
+          keyof MongoModelsMap<TContract>
+        ? C extends 'N:1' | '1:1'
+          ? InferFullRow<TContract, To> | null
+          : InferFullRow<TContract, To>[]
+        : never
+      : never
     : never
   : never;
 
 export type IncludeResultFields<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   TInclude extends MongoIncludeSpec<TContract, ModelName>,
 > = {
   -readonly [K in keyof TInclude & string as TInclude[K] extends true
@@ -174,10 +185,10 @@ export type IncludeResultFields<
 
 export type MongoWhereFilter<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
 > = {
-  readonly [K in keyof TContract['models'][ModelName]['fields']]?: TContract['models'][ModelName]['fields'][K] extends {
+  readonly [K in keyof MongoModelsMap<TContract>[ModelName]['fields']]?: MongoModelsMap<TContract>[ModelName]['fields'][K] extends {
     readonly type: {
       readonly kind: 'scalar';
       readonly codecId: infer CId extends string & keyof TCodecTypes;
@@ -189,7 +200,7 @@ export type MongoWhereFilter<
 
 export type MongoIncludeSpec<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
   readonly [K in ReferenceRelationKeys<TContract, ModelName>]?: true;
 };
@@ -198,18 +209,18 @@ export type NoIncludes = Pick<Record<string, boolean>, never>;
 
 export type IncludedRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   TIncludes extends MongoIncludeSpec<TContract, ModelName> = NoIncludes,
 > = InferRootRow<TContract, ModelName> & IncludeResultFields<TContract, ModelName, TIncludes>;
 
 export type DefaultModelRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = ResolvedOutputRow<TContract, ModelName>;
 
 export type CreateInput<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = Omit<ResolvedInputRow<TContract, ModelName>, '_id'> &
   Partial<
     Pick<
@@ -220,8 +231,8 @@ export type CreateInput<
 
 type DiscriminatorField<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
-> = TContract['models'][ModelName] extends {
+  ModelName extends string & keyof MongoModelsMap<TContract>,
+> = MongoModelsMap<TContract>[ModelName] extends {
   readonly discriminator: { readonly field: infer F extends string };
 }
   ? F
@@ -233,7 +244,7 @@ type DiscriminatorField<
 // input-side VariantModelRow.
 export type VariantCreateInput<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   VariantName extends string,
 > = Omit<
   VariantModelRow<TContract, ModelName, VariantName>,
@@ -248,7 +259,7 @@ export type VariantCreateInput<
 
 export type ResolvedCreateInput<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
   TVariant extends string,
 > = [TVariant] extends [never]
   ? CreateInput<TContract, ModelName>