@prisma-next/mongo-query-builder 0.11.0 → 0.12.0

package/package.json

@@ -1,33 +1,44 @@
 {
   "name": "@prisma-next/mongo-query-builder",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Type-safe MongoDB query builder (reads, writes, find-and-modify, pipeline-terminal writes) with document shape tracking",
   "dependencies": {
-    "@prisma-next/contract": "0.11.0",
-    "@prisma-next/mongo-contract": "0.11.0",
-    "@prisma-next/mongo-query-ast": "0.11.0",
-    "@prisma-next/mongo-value": "0.11.0",
-    "@prisma-next/utils": "0.11.0"
+    "@prisma-next/contract": "0.12.0",
+    "@prisma-next/mongo-contract": "0.12.0",
+    "@prisma-next/mongo-query-ast": "0.12.0",
+    "@prisma-next/mongo-value": "0.12.0",
+    "@prisma-next/utils": "0.12.0"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.11.0",
-    "@prisma-next/tsdown": "0.11.0",
+    "@prisma-next/tsconfig": "0.12.0",
+    "@prisma-next/tsdown": "0.12.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
   },
+  "peerDependencies": {
+    "typescript": ">=5.9"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
   "files": [
     "dist",
     "src"
   ],
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.mts",
+  "engines": {
+    "node": ">=24"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/prisma/prisma-next.git",

package/src/builder.ts

@@ -1,4 +1,4 @@
-import type { PlanMeta } from '@prisma-next/contract/types';
+import { contractModels, type PlanMeta } from '@prisma-next/contract/types';
 import type {
   ExtractMongoCodecTypes,
   MongoContract,
@@ -820,7 +820,7 @@ export class PipelineChain<
     let resultShape: MongoResultShape | undefined;
     if (modelName !== undefined) {
       if (pipelineSupportsFlatResultShape(this.#state.stages)) {
-        const model = contractNarrow.models[modelName] as MongoModelDefinition | undefined;
+        const model = contractModels(contractNarrow)[modelName] as MongoModelDefinition | undefined;
         resultShape = model ? contractModelToMongoResultShape(model) : { kind: 'unknown' as const };
       } else {
         resultShape = { kind: 'unknown' as const };

package/src/lookup-builder.ts

@@ -1,20 +1,26 @@
-import type { MongoContract } from '@prisma-next/mongo-contract';
+import { contractModels } from '@prisma-next/contract/types';
+import type {
+  MongoContract,
+  MongoModelDefinition,
+  MongoModelsMap,
+  RootModelName,
+} from '@prisma-next/mongo-contract';
 import { createFieldAccessor, type FieldAccessor, type LeafExpression } from './field-accessor';
 import type { ModelNestedShape } from './resolve-path';
 import type { DocField, DocShape, ModelToDocShape } from './types';
 
 /**
  * Resolved foreign-model name for a contract root. Looks `RootName` up
- * through `TContract['roots']` and intersects the result back with
- * `keyof TContract['models']` so it can be used as a `ModelName` index
- * into `models`. Resolves to `never` when the root is not present (this
- * surface should never be reachable through normal use because `from()`
- * constrains its `R` parameter to `keyof TContract['roots']`).
+ * through `TContract['roots']` and extracts the referenced model name
+ * so it can be used as a `ModelName` index into `models`. Resolves to
+ * `never` when the root is not present (this surface should never be
+ * reachable through normal use because `from()` constrains its `R`
+ * parameter to `keyof TContract['roots']`).
  */
 export type ModelOf<
   TContract extends MongoContract,
   RootName extends keyof TContract['roots'] & string,
-> = TContract['roots'][RootName] & string & keyof TContract['models'];
+> = RootModelName<TContract, RootName>;
 
 /**
  * Object returned by the user from the `on(...)` callback. Each side is
@@ -92,7 +98,7 @@ export interface LookupBuilder<
   on(
     cb: (
       local: FieldAccessor<Shape, Nested>,
-      foreign: ModelName extends keyof TContract['models'] & string
+      foreign: ModelName extends keyof MongoModelsMap<TContract> & string
         ? FieldAccessor<
             ModelToDocShape<TContract, ModelName>,
             ModelNestedShape<TContract, ModelName>
@@ -137,12 +143,12 @@ export function createLookupFrom<
   Nested extends Record<string, DocField>,
 >(contract: TContract): LookupFrom<TContract, Shape, Nested> {
   const callable = ((rootName) => {
-    const modelName = contract.roots[rootName];
+    const modelName = contract.roots[rootName]?.model;
     if (!modelName) {
       const validRoots = Object.keys(contract.roots).join(', ');
       throw new Error(`lookup() unknown root: "${rootName}". Valid roots: ${validRoots}`);
     }
-    const model = contract.models[modelName];
+    const model = contractModels(contract)[modelName] as MongoModelDefinition | undefined;
     const foreignCollection = model?.storage?.collection ?? rootName;
     return createLookupBuilder({
       rootName,
@@ -260,7 +266,7 @@ export function extractLookupResult(
         'Returning a hand-rolled options object is not supported.',
     );
   }
-  const model = contract.models[result._model];
+  const model = contractModels(contract)[result._model] as MongoModelDefinition | undefined;
   const foreignCollection = model?.storage?.collection ?? result._root;
   return {
     foreignCollection,

package/src/query.ts

@@ -3,8 +3,10 @@ import type {
   MongoContract,
   MongoContractWithTypeMaps,
   MongoTypeMaps,
+  RootModelName,
 } from '@prisma-next/mongo-contract';
 import type { AnyMongoCommand, MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
+import { blindCast } from '@prisma-next/utils/casts';
 import { asMongoContract, type CollectionHandle, createCollectionHandle } from './state-classes';
 
 /**
@@ -23,14 +25,17 @@ export interface QueryRoot<
 > {
   from<K extends keyof TContract['roots'] & string>(
     rootName: K,
-  ): CollectionHandle<TContract, TContract['roots'][K] & string & keyof TContract['models']>;
+  ): CollectionHandle<TContract, RootModelName<TContract, K>>;
   rawCommand<C extends AnyMongoCommand>(command: C): MongoQueryPlan<unknown, C>;
 }
 
 export function mongoQuery<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
 >(options: { contractJson: unknown }): QueryRoot<TContract> {
-  const contract = options.contractJson as TContract;
+  const contract = blindCast<
+    TContract,
+    'mongoQuery accepts validated contract JSON with domain.namespaces'
+  >(options.contractJson);
   return {
     from<K extends keyof TContract['roots'] & string>(rootName: K) {
       return createCollectionHandle(contract, rootName);

package/src/resolve-path.ts

@@ -1,4 +1,5 @@
-import type { MongoContract } from '@prisma-next/mongo-contract';
+import type { ContractValueObjectsMap } from '@prisma-next/contract/types';
+import type { MongoContract, MongoModelsMap } from '@prisma-next/mongo-contract';
 import type { DocField } from './types';
 
 /**
@@ -95,10 +96,6 @@ export type NestedDocShape = Record<string, DocField>;
 
 // ── Contract → NestedDocShape translation ────────────────────────────────
 
-type ContractHasValueObjects = {
-  readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;
-};
-
 type FieldToLeaf<F> = F extends {
   readonly type: { readonly kind: 'scalar'; readonly codecId: infer C extends string };
   readonly nullable: infer N extends boolean;
@@ -122,7 +119,7 @@ type FieldToLeaf<F> = F extends {
  * `ModelNestedShape` hover output and `keyof`/indexed-access resolution
  * concrete instead of collapsing to `{ [x: string]: … }`.
  */
-type TranslateField<TContract extends ContractHasValueObjects, F> = F extends {
+type TranslateField<TContract extends MongoContract, F> = F extends {
   readonly many: true;
 }
   ? FieldToLeaf<F>
@@ -147,16 +144,10 @@ type TranslateField<TContract extends ContractHasValueObjects, F> = F extends {
  * `VOs[VOName]['fields']` is preserved and the hover / indexed-access
  * surface stays concrete at instantiation time.
  */
-type VONestedShape<
-  TContract extends ContractHasValueObjects,
-  VOName extends string,
-> = TContract extends {
-  readonly valueObjects: infer VOs extends Record<
-    string,
-    { readonly fields: Record<string, unknown> }
-  >;
-}
-  ? VOName extends keyof VOs
+type VONestedShape<TContract extends MongoContract, VOName extends string> = [
+  ContractValueObjectsMap<TContract>,
+] extends [infer VOs extends Record<string, { readonly fields: Record<string, unknown> }>]
+  ? VOName extends keyof VOs & string
     ? {
         readonly [K in keyof VOs[VOName]['fields'] & string]: TranslateField<
           TContract,
@@ -174,7 +165,7 @@ type VONestedShape<
  *
  * The mapped iteration is inlined (not hidden behind a helper type that
  * takes `Fields` as a generic) so TypeScript recognises the mapped type
- * as homomorphic over `TContract['models'][ModelName]['fields']`. That
+ * as homomorphic over `MongoModelsMap<TContract>[ModelName]['fields']`. That
  * preserves the literal field-name keys at instantiation — without this,
  * the intersection of `Record<string, ContractField>` and the specific
  * literal field record collapses `keyof` to `string` and the result hover
@@ -182,11 +173,11 @@ type VONestedShape<
  */
 export type ModelNestedShape<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
-  readonly [K in keyof TContract['models'][ModelName]['fields'] & string]: TranslateField<
-    TContract & ContractHasValueObjects,
-    TContract['models'][ModelName]['fields'][K]
+  readonly [K in keyof MongoModelsMap<TContract>[ModelName]['fields'] & string]: TranslateField<
+    TContract,
+    MongoModelsMap<TContract>[ModelName]['fields'][K]
   >;
 };
 

package/src/state-classes.ts

@@ -1,9 +1,12 @@
-import type { PlanMeta } from '@prisma-next/contract/types';
+import { contractModels, type PlanMeta } from '@prisma-next/contract/types';
 import type {
   ExtractMongoCodecTypes,
   MongoContract,
   MongoContractWithTypeMaps,
+  MongoModelDefinition,
+  MongoModelsMap,
   MongoTypeMaps,
+  RootModelName,
 } from '@prisma-next/mongo-contract';
 import type {
   DeleteResult,
@@ -92,7 +95,7 @@ function writeMeta(storageHash: string): PlanMeta {
  */
 export class CollectionHandle<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends keyof TContract['models'] & string,
+  ModelName extends keyof MongoModelsMap<TContract> & string,
 > extends PipelineChain<
   TContract,
   ModelToDocShape<TContract, ModelName>,
@@ -316,7 +319,7 @@ export class CollectionHandle<
  */
 export class FilteredCollection<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends keyof TContract['models'] & string,
+  ModelName extends keyof MongoModelsMap<TContract> & string,
 > extends PipelineChain<
   TContract,
   ModelToDocShape<TContract, ModelName>,
@@ -632,18 +635,18 @@ export function createCollectionHandle<
 >(
   contract: TContract,
   rootName: RootName,
-): CollectionHandle<TContract, TContract['roots'][RootName] & string & keyof TContract['models']> {
+): CollectionHandle<TContract, RootModelName<TContract, RootName>> {
   const c = asMongoContract(contract);
-  const modelName = c.roots[rootName];
+  const modelName = c.roots[rootName]?.model;
   if (!modelName) {
     const validRoots = Object.keys(c.roots).join(', ');
     throw new Error(`Unknown root: "${rootName}". Valid roots: ${validRoots}`);
   }
-  const model = c.models[modelName];
+  const model = contractModels(c)[modelName] as MongoModelDefinition | undefined;
   if (!model) {
     throw new Error(`Unknown model: "${modelName}" referenced by root "${rootName}".`);
   }
-  const collectionName = model.storage?.collection ?? rootName;
+  const collectionName = model.storage.collection ?? rootName;
   if (!c.storage?.storageHash) {
     throw new Error(
       'Contract is missing storage.storageHash. Pass a validated contract to mongoQuery().',
@@ -655,6 +658,6 @@ export function createCollectionHandle<
       collection: collectionName,
       storageHash: String(c.storage.storageHash),
     },
-    modelName as TContract['roots'][RootName] & string & keyof TContract['models'],
+    modelName as RootModelName<TContract, RootName>,
   );
 }

package/src/types.ts

@@ -3,6 +3,7 @@ import type {
   InferModelRow,
   MongoContract,
   MongoContractWithTypeMaps,
+  MongoModelsMap,
   MongoTypeMaps,
 } from '@prisma-next/mongo-contract';
 import type { MongoAggAccumulator, MongoAggExpr } from '@prisma-next/mongo-query-ast/execution';
@@ -41,11 +42,11 @@ type ExtractCodecId<F> = F extends { type: { kind: 'scalar'; codecId: infer C }
 
 export type ModelToDocShape<
   TContract extends MongoContract,
-  ModelName extends string & keyof TContract['models'],
+  ModelName extends string & keyof MongoModelsMap<TContract>,
 > = {
-  [K in keyof TContract['models'][ModelName]['fields'] & string]: {
-    readonly codecId: ExtractCodecId<TContract['models'][ModelName]['fields'][K]>;
-    readonly nullable: TContract['models'][ModelName]['fields'][K]['nullable'];
+  [K in keyof MongoModelsMap<TContract>[ModelName]['fields'] & string]: {
+    readonly codecId: ExtractCodecId<MongoModelsMap<TContract>[ModelName]['fields'][K]>;
+    readonly nullable: MongoModelsMap<TContract>[ModelName]['fields'][K]['nullable'];
   };
 } & ModelOriginBranded<ModelName>;
 
@@ -65,7 +66,7 @@ type ResolveFields<
   -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']
+        ? ModelName extends string & keyof MongoModelsMap<TContract>
           ? Array<InferModelRow<TContract, ModelName>>
           : unknown[]
         : unknown[]
@@ -131,7 +132,7 @@ export type ResolveRow<
 > = Shape extends { readonly [ModelOriginBrand]?: infer ModelName extends string }
   ? IsConcreteContract<TContract> extends true
     ? TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>
-      ? ModelName extends string & keyof TContract['models']
+      ? ModelName extends string & keyof MongoModelsMap<TContract>
         ? Flatten<
             InferModelRow<TContract, ModelName> &
               Omit<