@prisma-next/mongo-orm 0.3.0-dev.135 → 0.3.0-dev.162

package/src/types.ts

@@ -1,25 +1,26 @@
-import type { DomainReferenceRelation } from '@prisma-next/contract/types';
+import type { ContractReferenceRelation } from '@prisma-next/contract/types';
 import type {
   ExtractMongoCodecTypes,
+  ExtractMongoFieldInputTypes,
+  ExtractMongoFieldOutputTypes,
   InferModelRow,
   MongoContract,
   MongoContractWithTypeMaps,
-  MongoQueryPlan,
   MongoTypeMaps,
-} from '@prisma-next/mongo-core';
-import type { AsyncIterableResult } from '@prisma-next/runtime-executor';
-
-export interface MongoQueryExecutor {
-  execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row>;
-}
-
-export interface MongoOrmOptions<TContract extends MongoContract> {
-  readonly contract: TContract;
-  readonly executor: MongoQueryExecutor;
-}
+} from '@prisma-next/mongo-contract';
 
 type Simplify<T> = T extends unknown ? { [K in keyof T]: T[K] } : never;
 
+export type SimplifyDeep<T> = T extends readonly (infer E)[]
+  ? SimplifyDeep<E>[]
+  : T extends Date | RegExp | ((...args: never[]) => unknown)
+    ? T
+    : T extends object
+      ? T extends unknown
+        ? { [K in keyof T]: SimplifyDeep<T[K]> }
+        : never
+      : T;
+
 type ModelRelations<
   TContract extends MongoContract,
   ModelName extends string & keyof TContract['models'],
@@ -32,7 +33,7 @@ export type ReferenceRelationKeys<
   [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
     TContract,
     ModelName
-  >[K] extends DomainReferenceRelation
+  >[K] extends ContractReferenceRelation
     ? K
     : never;
 }[keyof ModelRelations<TContract, ModelName>];
@@ -44,11 +45,33 @@ export type EmbedRelationKeys<
   [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
     TContract,
     ModelName
-  >[K] extends DomainReferenceRelation
+  >[K] extends ContractReferenceRelation
     ? never
     : K;
 }[keyof ModelRelations<TContract, ModelName>];
 
+type ResolvedOutputRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = string extends keyof ExtractMongoFieldOutputTypes<TContract>
+  ? InferModelRow<TContract, ModelName>
+  : ModelName extends keyof ExtractMongoFieldOutputTypes<TContract>
+    ? {
+        -readonly [K in keyof ExtractMongoFieldOutputTypes<TContract>[ModelName]]: ExtractMongoFieldOutputTypes<TContract>[ModelName][K];
+      }
+    : InferModelRow<TContract, ModelName>;
+
+type ResolvedInputRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = string extends keyof ExtractMongoFieldInputTypes<TContract>
+  ? InferModelRow<TContract, ModelName>
+  : ModelName extends keyof ExtractMongoFieldInputTypes<TContract>
+    ? {
+        -readonly [K in keyof ExtractMongoFieldInputTypes<TContract>[ModelName]]: ExtractMongoFieldInputTypes<TContract>[ModelName][K];
+      }
+    : InferModelRow<TContract, ModelName>;
+
 type EmbedRelationRowType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
   ModelName extends string & keyof TContract['models'],
@@ -57,19 +80,19 @@ type EmbedRelationRowType<
   readonly to: infer To extends string & keyof TContract['models'];
   readonly cardinality: infer C;
 }
-  ? ModelRelations<TContract, ModelName>[RelKey] extends DomainReferenceRelation
+  ? ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation
     ? never
     : C extends '1:N'
-      ? InferModelRow<TContract, To>[]
-      : InferModelRow<TContract, To>
+      ? ResolvedOutputRow<TContract, To>[]
+      : ResolvedOutputRow<TContract, To>
   : never;
 
 export type InferFullRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
   ModelName extends string & keyof TContract['models'],
 > = EmbedRelationKeys<TContract, ModelName> extends never
-  ? InferModelRow<TContract, ModelName>
-  : InferModelRow<TContract, ModelName> & {
+  ? ResolvedOutputRow<TContract, ModelName>
+  : ResolvedOutputRow<TContract, ModelName> & {
       -readonly [K in EmbedRelationKeys<TContract, ModelName> &
         keyof ModelRelations<TContract, ModelName>]: EmbedRelationRowType<TContract, ModelName, K>;
     };
@@ -99,11 +122,39 @@ export type InferRootRow<
   ModelName extends string & keyof TContract['models'],
 > = VariantRow<TContract, ModelName>;
 
+export type VariantNames<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = TContract['models'][ModelName] extends {
+  readonly variants: infer V extends Record<string, unknown>;
+}
+  ? keyof V & string
+  : never;
+
+export type VariantModelRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  VariantName extends string,
+> = TContract['models'][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']
+      ? Simplify<
+          Omit<InferFullRow<TContract, ModelName>, DiscField> &
+            InferFullRow<TContract, VariantName> &
+            Record<DiscField, V[VariantName]['value']>
+        >
+      : InferFullRow<TContract, ModelName>
+    : InferFullRow<TContract, ModelName>
+  : InferFullRow<TContract, ModelName>;
+
 type IncludeRelationRowType<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
   ModelName extends string & keyof TContract['models'],
   RelKey extends keyof ModelRelations<TContract, ModelName>,
-> = ModelRelations<TContract, ModelName>[RelKey] extends DomainReferenceRelation
+> = ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation
   ? ModelRelations<TContract, ModelName>[RelKey] extends {
       readonly to: infer To extends string & keyof TContract['models'];
       readonly cardinality: infer C;
@@ -132,7 +183,10 @@ export type MongoWhereFilter<
   TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
 > = {
   readonly [K in keyof TContract['models'][ModelName]['fields']]?: TContract['models'][ModelName]['fields'][K] extends {
-    readonly codecId: infer CId extends string & keyof TCodecTypes;
+    readonly type: {
+      readonly kind: 'scalar';
+      readonly codecId: infer CId extends string & keyof TCodecTypes;
+    };
   }
     ? TCodecTypes[CId]['output']
     : unknown;
@@ -145,31 +199,62 @@ export type MongoIncludeSpec<
   readonly [K in ReferenceRelationKeys<TContract, ModelName>]?: true;
 };
 
-export interface MongoFindManyOptions<
+export type NoIncludes = Pick<Record<string, boolean>, never>;
+
+export type IncludedRow<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
   ModelName extends string & keyof TContract['models'],
-  TInclude extends MongoIncludeSpec<TContract, ModelName> = Record<string, never>,
-> {
-  readonly where?: MongoWhereFilter<TContract, ModelName>;
-  readonly include?: TInclude;
-}
+  TIncludes extends MongoIncludeSpec<TContract, ModelName> = NoIncludes,
+> = InferRootRow<TContract, ModelName> & IncludeResultFields<TContract, ModelName, TIncludes>;
 
-export type MongoOrmClient<
+export type DefaultModelRow<
   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;
-};
+  ModelName extends string & keyof TContract['models'],
+> = ResolvedOutputRow<TContract, ModelName>;
 
-export interface MongoCollection<
+export type CreateInput<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
   ModelName extends string & keyof TContract['models'],
-> {
-  findMany<TInclude extends MongoIncludeSpec<TContract, ModelName> = Record<string, never>>(
-    options?: MongoFindManyOptions<TContract, ModelName, TInclude>,
-  ): AsyncIterableResult<
-    InferRootRow<TContract, ModelName> & IncludeResultFields<TContract, ModelName, TInclude>
+> = Omit<ResolvedInputRow<TContract, ModelName>, '_id'> &
+  Partial<
+    Pick<
+      ResolvedInputRow<TContract, ModelName>,
+      '_id' & keyof ResolvedInputRow<TContract, ModelName>
+    >
   >;
+
+type DiscriminatorField<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = TContract['models'][ModelName] extends {
+  readonly discriminator: { readonly field: infer F extends string };
 }
+  ? F
+  : never;
+
+// TODO(TML-2229): VariantModelRow flows through ResolvedOutputRow, so variant
+// domain fields use output types. Only the _id pick uses ResolvedInputRow.
+// When input/output types diverge (parameterized codecs), this needs an
+// input-side VariantModelRow.
+export type VariantCreateInput<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  VariantName extends string,
+> = Omit<
+  VariantModelRow<TContract, ModelName, VariantName>,
+  '_id' | DiscriminatorField<TContract, ModelName>
+> &
+  Partial<
+    Pick<
+      ResolvedInputRow<TContract, ModelName>,
+      '_id' & keyof ResolvedInputRow<TContract, ModelName>
+    >
+  >;
+
+export type ResolvedCreateInput<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  TVariant extends string,
+> = [TVariant] extends [never]
+  ? CreateInput<TContract, ModelName>
+  : VariantCreateInput<TContract, ModelName, TVariant>;