@prisma-next/mongo-query-builder 0.5.0-dev.9 → 0.5.1

package/src/state-classes.ts

@@ -71,7 +71,6 @@ function writeMeta(storageHash: string): PlanMeta {
     target: 'mongo',
     storageHash,
     lane: 'mongo-query',
-    paramDescriptors: [],
   };
 }
 
@@ -110,6 +109,7 @@ export class CollectionHandle<
       collection: ctx.collection,
       stages: [],
       storageHash: ctx.storageHash,
+      modelName: modelName as string,
     });
     this.#ctx = ctx;
     this.#modelName = modelName;
@@ -346,6 +346,7 @@ export class FilteredCollection<
       collection: ctx.collection,
       stages: [new MongoMatchStage(leading)],
       storageHash: ctx.storageHash,
+      modelName: modelName as string,
     });
     this.#ctx = ctx;
     this.#modelName = modelName;
@@ -545,7 +546,11 @@ export class FilteredCollection<
     ) => UpdaterResult,
     opts: { readonly upsert?: boolean; readonly returnDocument?: 'before' | 'after' } = {},
   ): MongoQueryPlan<
-    ResolveRow<ModelToDocShape<TContract, ModelName>, ExtractMongoCodecTypes<TContract>> | null,
+    ResolveRow<
+      ModelToDocShape<TContract, ModelName>,
+      ExtractMongoCodecTypes<TContract>,
+      TContract
+    > | null,
     FindOneAndUpdateCommand
   > {
     const update = resolveUpdaterCallback<
@@ -572,7 +577,11 @@ export class FilteredCollection<
    * document via the row stream.
    */
   override findOneAndDelete(): MongoQueryPlan<
-    ResolveRow<ModelToDocShape<TContract, ModelName>, ExtractMongoCodecTypes<TContract>> | null,
+    ResolveRow<
+      ModelToDocShape<TContract, ModelName>,
+      ExtractMongoCodecTypes<TContract>,
+      TContract
+    > | null,
     FindOneAndDeleteCommand
   > {
     const command = new FindOneAndDeleteCommand(this.#ctx.collection, this.#foldedFilter());

package/src/types.ts

@@ -1,5 +1,12 @@
-import type { MongoContract } from '@prisma-next/mongo-contract';
+import type {
+  ExtractMongoTypeMaps,
+  InferModelRow,
+  MongoContract,
+  MongoContractWithTypeMaps,
+  MongoTypeMaps,
+} from '@prisma-next/mongo-contract';
 import type { MongoAggAccumulator, MongoAggExpr } from '@prisma-next/mongo-query-ast/execution';
+import type { ModelArrayField, ModelOriginBrand, ModelOriginBranded } from './resolve-path';
 
 export interface DocField {
   readonly codecId: string;
@@ -40,19 +47,103 @@ export type ModelToDocShape<
     readonly codecId: ExtractCodecId<TContract['models'][ModelName]['fields'][K]>;
     readonly nullable: TContract['models'][ModelName]['fields'][K]['nullable'];
   };
-};
+} & ModelOriginBranded<ModelName>;
 
-export type ResolveRow<
+/**
+ * Per-field resolver. Walks `Shape`'s string keys, routing
+ * `ModelArrayField` (the lookup marker) through `InferModelRow` and
+ * everything else through the codec-lookup branch.
+ *
+ * Internal helper — public callers should use `ResolveRow`, which adds
+ * the model-origin brand detection on top.
+ */
+type ResolveFields<
   Shape extends DocShape,
   CodecTypes extends Record<string, { readonly output: unknown }>,
+  TContract extends MongoContract,
 > = {
-  -readonly [K in keyof Shape & string]: Shape[K]['codecId'] extends keyof CodecTypes
-    ? Shape[K]['nullable'] extends true
-      ? CodecTypes[Shape[K]['codecId']]['output'] | null
-      : CodecTypes[Shape[K]['codecId']]['output']
-    : unknown;
+  -readonly [K in keyof Shape & string]: Shape[K] extends ModelArrayField<infer ModelName>
+    ? IsConcreteContract<TContract> extends true
+      ? TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>
+        ? ModelName extends string & keyof TContract['models']
+          ? Array<InferModelRow<TContract, ModelName>>
+          : unknown[]
+        : unknown[]
+      : unknown[]
+    : Shape[K]['codecId'] extends keyof CodecTypes
+      ? Shape[K]['nullable'] extends true
+        ? CodecTypes[Shape[K]['codecId']]['output'] | null
+        : CodecTypes[Shape[K]['codecId']]['output']
+      : unknown;
 };
 
+/**
+ * Resolve a `DocShape` to a concrete row object type.
+ *
+ * The optional `TContract` parameter exists so the resolver can:
+ *
+ *  1. Detect the `ModelOriginBrand` on `Shape` — the phantom symbol
+ *     placed by `ModelToDocShape`. When present (and the contract has
+ *     type maps), the row is resolved via `InferModelRow<TC, M>` from
+ *     `@prisma-next/mongo-contract`, which walks scalar / valueObject /
+ *     union field kinds (handling nested value-objects and `many: true`).
+ *     This makes entry-point reads (`q.from('users').build()`) and
+ *     shape-extending stages (`match`, `addFields`) resolve value-object
+ *     fields to their concrete nested types instead of `unknown`.
+ *
+ *  2. Detect the per-field `ModelArrayField<ModelName>` marker produced
+ *     by `lookup()` and resolve it to `Array<InferModelRow<TC, M>>` so
+ *     lookup rows carry the same fully-typed foreign rows.
+ *
+ * When the contract is not threaded through (or lacks the type-map
+ * phantom), both branches fall back to `unknown` / `unknown[]` —
+ * preserving the legacy resolver shape for call sites that do not need
+ * model-row resolution.
+ */
+/**
+ * Flatten an intersection `A & B` into a single object literal so callers
+ * (and `expectTypeOf().toEqualTypeOf<…>()`) see one homogeneous record
+ * rather than the intersection form. Vitest's strict equality check
+ * treats `A & B` as distinct from the structurally-equivalent flat
+ * record, even when assignability is bidirectional, so the
+ * `ResolveRow` brand-positive branch normalises its result through this.
+ */
+type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
+
+/**
+ * Decide whether to route a brand-positive `ResolveRow` through
+ * `InferModelRow`. The default `MongoContract` (no concrete models)
+ * still satisfies `MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>`
+ * because the phantom key is optional, but `InferModelRow<MongoContract, …>`
+ * collapses to an empty/unknown row. Gate on the presence of the
+ * type-maps phantom: a concrete contract attaches concrete `TestTypeMaps`-
+ * shaped maps, while the default `MongoContract` has no phantom and
+ * `ExtractMongoTypeMaps` resolves to `never`.
+ */
+type IsConcreteContract<TContract> = [ExtractMongoTypeMaps<TContract>] extends [never]
+  ? false
+  : true;
+
+export type ResolveRow<
+  Shape extends DocShape,
+  CodecTypes extends Record<string, { readonly output: unknown }>,
+  TContract extends MongoContract = MongoContract,
+> = Shape extends { readonly [ModelOriginBrand]?: infer ModelName extends string }
+  ? IsConcreteContract<TContract> extends true
+    ? TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>
+      ? ModelName extends string & keyof TContract['models']
+        ? Flatten<
+            InferModelRow<TContract, ModelName> &
+              Omit<
+                ResolveFields<Shape, CodecTypes, TContract>,
+                keyof InferModelRow<TContract, ModelName>
+              >
+          >
+        : ResolveFields<Shape, CodecTypes, TContract>
+      : ResolveFields<Shape, CodecTypes, TContract>
+    : ResolveFields<Shape, CodecTypes, TContract>
+  : ResolveFields<Shape, CodecTypes, TContract>;
+
 export interface TypedAggExpr<F extends DocField> {
   readonly _field: F;
   readonly node: MongoAggExpr;
@@ -108,6 +199,16 @@ export type GroupedDocShape<Spec extends GroupSpec> = {
  */
 type UnwrapArrayDocField<F extends DocField> = F;
 
+/**
+ * `$unwind` reshapes the array slot but leaves the rest of the document
+ * structurally intact. The mapped iteration is keyed on `keyof S & string`,
+ * which discards the symbol-keyed `ModelOriginBrand` carried by
+ * model-rooted shapes. Preserve the brand explicitly so post-unwind
+ * `ResolveRow` still routes through `InferModelRow` and value-object
+ * fields keep their concrete nested types.
+ */
 export type UnwoundShape<S extends DocShape, K extends keyof S & string> = {
   [P in keyof S & string]: P extends K ? UnwrapArrayDocField<S[P]> : S[P];
-};
+} & (S extends ModelOriginBranded<infer ModelName extends string>
+  ? ModelOriginBranded<ModelName>
+  : unknown);