@prisma-next/mongo-orm 0.0.1

package/README.md

@@ -0,0 +1,19 @@
+# @prisma-next/mongo-orm
+
+MongoDB ORM client for Prisma Next.
+
+## Responsibilities
+
+- **ORM client factory**: `mongoOrm()` creates a typed client with root-based collection accessors
+- **Typed queries**: `findMany` with equality filters (`MongoWhereFilter`) and reference includes (`MongoIncludeSpec`)
+- **Row type inference**: `InferFullRow` (scalar fields + embedded documents), `InferRootRow` (discriminated union for polymorphic roots), `IncludeResultFields`
+- **Polymorphic narrowing**: Discriminator field carries literal variant values, enabling TypeScript `switch`/`if` narrowing
+- **Execution interface**: Declares `MongoQueryExecutor` interface structurally satisfied by the runtime layer
+
+## Dependencies
+
+- **Depends on**:
+  - `@prisma-next/mongo-core` (contract types, row inference, query plan types)
+  - `@prisma-next/runtime-executor` (`AsyncIterableResult` return type)
+- **Depended on by**:
+  - `@prisma-next/mongo-runtime` (structurally satisfies `MongoQueryExecutor`)

package/dist/index.d.mts

@@ -0,0 +1,59 @@
+import { ExtractMongoCodecTypes, InferModelRow, MongoContract, MongoContractWithTypeMaps, MongoQueryPlan, MongoTypeMaps } from "@prisma-next/mongo-core";
+import { AsyncIterableResult } from "@prisma-next/runtime-executor";
+
+//#region src/types.d.ts
+interface MongoQueryExecutor {
+  execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row>;
+}
+interface MongoOrmOptions<TContract extends MongoContract> {
+  readonly contract: TContract;
+  readonly executor: MongoQueryExecutor;
+}
+type Simplify<T> = T extends unknown ? { [K in keyof T]: T[K] } : never;
+type ReferenceRelationKeys<TContract extends MongoContract, ModelName extends string & keyof TContract['models']> = { [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends {
+  readonly strategy: 'reference';
+} ? K : never }[keyof TContract['models'][ModelName]['relations']];
+type EmbedRelationKeys<TContract extends MongoContract, ModelName extends string & keyof TContract['models']> = { [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends {
+  readonly strategy: 'embed';
+} ? K : never }[keyof TContract['models'][ModelName]['relations']];
+type EmbedRelationRowType<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models'], RelKey extends keyof TContract['models'][ModelName]['relations']> = TContract['models'][ModelName]['relations'][RelKey] extends {
+  readonly to: infer To extends string & keyof TContract['models'];
+  readonly cardinality: infer C;
+  readonly strategy: 'embed';
+} ? C extends '1:N' ? InferModelRow<TContract, To>[] : InferModelRow<TContract, To> : never;
+type InferFullRow<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models']> = EmbedRelationKeys<TContract, ModelName> extends never ? InferModelRow<TContract, ModelName> : InferModelRow<TContract, ModelName> & { -readonly [K in EmbedRelationKeys<TContract, ModelName> & keyof TContract['models'][ModelName]['relations']]: EmbedRelationRowType<TContract, ModelName, K> };
+type VariantRow<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models']> = TContract['models'][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'] ? Simplify<Omit<InferFullRow<TContract, ModelName>, DiscField> & InferFullRow<TContract, VK> & Record<DiscField, V[VK]['value']>> : never }[keyof V] : InferFullRow<TContract, ModelName> : InferFullRow<TContract, ModelName>;
+type InferRootRow<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models']> = VariantRow<TContract, ModelName>;
+type IncludeRelationRowType<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models'], RelKey extends keyof TContract['models'][ModelName]['relations']> = TContract['models'][ModelName]['relations'][RelKey] extends {
+  readonly to: infer To extends string & keyof TContract['models'];
+  readonly cardinality: infer C;
+  readonly strategy: 'reference';
+} ? C extends 'N:1' | '1:1' ? InferFullRow<TContract, To> | null : InferFullRow<TContract, To>[] : never;
+type IncludeResultFields<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models'], TInclude extends MongoIncludeSpec<TContract, ModelName>> = { -readonly [K in keyof TInclude & string as TInclude[K] extends true ? K : never]: K extends keyof TContract['models'][ModelName]['relations'] ? IncludeRelationRowType<TContract, ModelName, K> : never };
+type MongoWhereFilter<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends string & keyof TContract['models'], 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;
+} ? TCodecTypes[CId]['output'] : unknown };
+type MongoIncludeSpec<TContract extends MongoContract, ModelName extends string & keyof TContract['models']> = { readonly [K in ReferenceRelationKeys<TContract, ModelName>]?: true };
+interface MongoFindManyOptions<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;
+}
+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 };
+interface MongoCollection<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>>;
+}
+//#endregion
+//#region src/mongo-orm.d.ts
+declare function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(options: MongoOrmOptions<TContract>): MongoOrmClient<TContract>;
+//#endregion
+export { type EmbedRelationKeys, type IncludeResultFields, type InferFullRow, type InferRootRow, type MongoCollection, type MongoFindManyOptions, type MongoIncludeSpec, type MongoOrmClient, type MongoOrmOptions, type MongoQueryExecutor, type MongoWhereFilter, type ReferenceRelationKeys, mongoOrm };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/mongo-orm.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,77 @@
+import { AggregateCommand, FindCommand } from "@prisma-next/mongo-core";
+
+//#region src/mongo-orm.ts
+const stubMeta = {
+	target: "mongo",
+	storageHash: "orm",
+	lane: "mongo-orm",
+	paramDescriptors: []
+};
+function resolveCollection(model, modelName) {
+	return model.storage.collection ?? modelName;
+}
+function buildLookupStages(contract, model, include) {
+	const stages = [];
+	for (const [relName, shouldInclude] of Object.entries(include)) {
+		if (!shouldInclude) continue;
+		const relation = model.relations[relName];
+		if (!relation || relation.strategy !== "reference") continue;
+		const refRelation = relation;
+		if (refRelation.on.localFields.length !== 1 || refRelation.on.targetFields.length !== 1) throw new Error(`Compound references are not yet supported: relation "${relName}" has ${refRelation.on.localFields.length} local field(s) and ${refRelation.on.targetFields.length} target field(s)`);
+		const targetModel = contract.models[refRelation.to];
+		if (!targetModel) continue;
+		const targetCollection = resolveCollection(targetModel, refRelation.to);
+		stages.push({ $lookup: {
+			from: targetCollection,
+			localField: refRelation.on.localFields[0],
+			foreignField: refRelation.on.targetFields[0],
+			as: relName
+		} });
+		if (refRelation.cardinality === "N:1" || refRelation.cardinality === "1:1") stages.push({ $unwind: {
+			path: `$${relName}`,
+			preserveNullAndEmptyArrays: true
+		} });
+	}
+	return stages;
+}
+var MongoCollectionImpl = class {
+	#contract;
+	#modelName;
+	#executor;
+	constructor(contract, modelName, executor) {
+		this.#contract = contract;
+		this.#modelName = modelName;
+		this.#executor = executor;
+	}
+	findMany(options) {
+		const model = this.#contract.models[this.#modelName];
+		const collection = resolveCollection(model, this.#modelName);
+		const filter = options?.where ? options.where : void 0;
+		const include = options?.include;
+		const hasIncludes = include && Object.keys(include).length > 0;
+		let plan;
+		if (hasIncludes) {
+			const pipeline = [];
+			if (filter && Object.keys(filter).length > 0) pipeline.push({ $match: filter });
+			pipeline.push(...buildLookupStages(this.#contract, model, include));
+			plan = {
+				command: new AggregateCommand(collection, pipeline),
+				meta: stubMeta
+			};
+		} else plan = {
+			command: new FindCommand(collection, filter),
+			meta: stubMeta
+		};
+		return this.#executor.execute(plan);
+	}
+};
+function mongoOrm(options) {
+	const { contract, executor } = options;
+	const client = {};
+	for (const [rootName, modelName] of Object.entries(contract.roots)) client[rootName] = new MongoCollectionImpl(contract, modelName, executor);
+	return client;
+}
+
+//#endregion
+export { mongoOrm };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["stubMeta: PlanMeta","stages: Record<string, unknown>[]","#contract","#modelName","#executor","plan: MongoQueryPlan","pipeline: Record<string, unknown>[]","client: Record<string, unknown>"],"sources":["../src/mongo-orm.ts"],"sourcesContent":["import type { PlanMeta } from '@prisma-next/contract/types';\nimport {\n  AggregateCommand,\n  FindCommand,\n  type MongoContract,\n  type MongoContractWithTypeMaps,\n  type MongoExpr,\n  type MongoModelDefinition,\n  type MongoQueryPlan,\n  type MongoReferenceRelation,\n  type MongoTypeMaps,\n} from '@prisma-next/mongo-core';\nimport type { AsyncIterableResult } from '@prisma-next/runtime-executor';\nimport type {\n  MongoFindManyOptions,\n  MongoIncludeSpec,\n  MongoOrmClient,\n  MongoOrmOptions,\n  MongoQueryExecutor,\n} from './types';\n\nconst stubMeta: PlanMeta = {\n  target: 'mongo',\n  storageHash: 'orm',\n  lane: 'mongo-orm',\n  paramDescriptors: [],\n};\n\nfunction resolveCollection(model: MongoModelDefinition, modelName: string): string {\n  return model.storage.collection ?? modelName;\n}\n\nfunction buildLookupStages(\n  contract: MongoContract,\n  model: MongoModelDefinition,\n  include: Record<string, true>,\n): Record<string, unknown>[] {\n  const stages: Record<string, unknown>[] = [];\n\n  for (const [relName, shouldInclude] of Object.entries(include)) {\n    if (!shouldInclude) continue;\n\n    const relation = model.relations[relName];\n    if (!relation || relation.strategy !== 'reference') continue;\n\n    const refRelation = relation as MongoReferenceRelation;\n\n    if (refRelation.on.localFields.length !== 1 || refRelation.on.targetFields.length !== 1) {\n      throw new Error(\n        `Compound references are not yet supported: relation \"${relName}\" has ${refRelation.on.localFields.length} local field(s) and ${refRelation.on.targetFields.length} target field(s)`,\n      );\n    }\n\n    const targetModel = contract.models[refRelation.to];\n    if (!targetModel) continue;\n\n    const targetCollection = resolveCollection(targetModel, refRelation.to);\n\n    stages.push({\n      $lookup: {\n        from: targetCollection,\n        localField: refRelation.on.localFields[0],\n        foreignField: refRelation.on.targetFields[0],\n        as: relName,\n      },\n    });\n\n    if (refRelation.cardinality === 'N:1' || refRelation.cardinality === '1:1') {\n      stages.push({\n        $unwind: {\n          path: `$${relName}`,\n          preserveNullAndEmptyArrays: true,\n        },\n      });\n    }\n  }\n\n  return stages;\n}\n\nclass MongoCollectionImpl<\n  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,\n  ModelName extends string & keyof TContract['models'],\n> {\n  readonly #contract: TContract;\n  readonly #modelName: ModelName;\n  readonly #executor: MongoQueryExecutor;\n\n  constructor(contract: TContract, modelName: ModelName, executor: MongoQueryExecutor) {\n    this.#contract = contract;\n    this.#modelName = modelName;\n    this.#executor = executor;\n  }\n\n  findMany<TInclude extends MongoIncludeSpec<TContract, ModelName> = Record<string, never>>(\n    options?: MongoFindManyOptions<TContract, ModelName, TInclude>,\n  ): AsyncIterableResult<unknown> {\n    const model = this.#contract.models[this.#modelName] as MongoModelDefinition;\n    const collection = resolveCollection(model, this.#modelName as string);\n    const filter = options?.where ? (options.where as unknown as MongoExpr) : undefined;\n    const include = options?.include as Record<string, true> | undefined;\n\n    const hasIncludes = include && Object.keys(include).length > 0;\n\n    let plan: MongoQueryPlan;\n    if (hasIncludes) {\n      const pipeline: Record<string, unknown>[] = [];\n\n      if (filter && Object.keys(filter as Record<string, unknown>).length > 0) {\n        pipeline.push({ $match: filter });\n      }\n\n      pipeline.push(...buildLookupStages(this.#contract, model, include));\n\n      plan = {\n        command: new AggregateCommand(collection, pipeline),\n        meta: stubMeta,\n      };\n    } else {\n      plan = {\n        command: new FindCommand(collection, filter),\n        meta: stubMeta,\n      };\n    }\n\n    return this.#executor.execute(plan);\n  }\n}\n\nexport function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(\n  options: MongoOrmOptions<TContract>,\n): MongoOrmClient<TContract> {\n  const { contract, executor } = options;\n  const client: Record<string, unknown> = {};\n\n  for (const [rootName, modelName] of Object.entries(contract.roots)) {\n    client[rootName] = new MongoCollectionImpl(\n      contract,\n      modelName as string & keyof TContract['models'],\n      executor,\n    );\n  }\n\n  return client as MongoOrmClient<TContract>;\n}\n"],"mappings":";;;AAqBA,MAAMA,WAAqB;CACzB,QAAQ;CACR,aAAa;CACb,MAAM;CACN,kBAAkB,EAAE;CACrB;AAED,SAAS,kBAAkB,OAA6B,WAA2B;AACjF,QAAO,MAAM,QAAQ,cAAc;;AAGrC,SAAS,kBACP,UACA,OACA,SAC2B;CAC3B,MAAMC,SAAoC,EAAE;AAE5C,MAAK,MAAM,CAAC,SAAS,kBAAkB,OAAO,QAAQ,QAAQ,EAAE;AAC9D,MAAI,CAAC,cAAe;EAEpB,MAAM,WAAW,MAAM,UAAU;AACjC,MAAI,CAAC,YAAY,SAAS,aAAa,YAAa;EAEpD,MAAM,cAAc;AAEpB,MAAI,YAAY,GAAG,YAAY,WAAW,KAAK,YAAY,GAAG,aAAa,WAAW,EACpF,OAAM,IAAI,MACR,wDAAwD,QAAQ,QAAQ,YAAY,GAAG,YAAY,OAAO,sBAAsB,YAAY,GAAG,aAAa,OAAO,kBACpK;EAGH,MAAM,cAAc,SAAS,OAAO,YAAY;AAChD,MAAI,CAAC,YAAa;EAElB,MAAM,mBAAmB,kBAAkB,aAAa,YAAY,GAAG;AAEvE,SAAO,KAAK,EACV,SAAS;GACP,MAAM;GACN,YAAY,YAAY,GAAG,YAAY;GACvC,cAAc,YAAY,GAAG,aAAa;GAC1C,IAAI;GACL,EACF,CAAC;AAEF,MAAI,YAAY,gBAAgB,SAAS,YAAY,gBAAgB,MACnE,QAAO,KAAK,EACV,SAAS;GACP,MAAM,IAAI;GACV,4BAA4B;GAC7B,EACF,CAAC;;AAIN,QAAO;;AAGT,IAAM,sBAAN,MAGE;CACA,CAASC;CACT,CAASC;CACT,CAASC;CAET,YAAY,UAAqB,WAAsB,UAA8B;AACnF,QAAKF,WAAY;AACjB,QAAKC,YAAa;AAClB,QAAKC,WAAY;;CAGnB,SACE,SAC8B;EAC9B,MAAM,QAAQ,MAAKF,SAAU,OAAO,MAAKC;EACzC,MAAM,aAAa,kBAAkB,OAAO,MAAKA,UAAqB;EACtE,MAAM,SAAS,SAAS,QAAS,QAAQ,QAAiC;EAC1E,MAAM,UAAU,SAAS;EAEzB,MAAM,cAAc,WAAW,OAAO,KAAK,QAAQ,CAAC,SAAS;EAE7D,IAAIE;AACJ,MAAI,aAAa;GACf,MAAMC,WAAsC,EAAE;AAE9C,OAAI,UAAU,OAAO,KAAK,OAAkC,CAAC,SAAS,EACpE,UAAS,KAAK,EAAE,QAAQ,QAAQ,CAAC;AAGnC,YAAS,KAAK,GAAG,kBAAkB,MAAKJ,UAAW,OAAO,QAAQ,CAAC;AAEnE,UAAO;IACL,SAAS,IAAI,iBAAiB,YAAY,SAAS;IACnD,MAAM;IACP;QAED,QAAO;GACL,SAAS,IAAI,YAAY,YAAY,OAAO;GAC5C,MAAM;GACP;AAGH,SAAO,MAAKE,SAAU,QAAQ,KAAK;;;AAIvC,SAAgB,SACd,SAC2B;CAC3B,MAAM,EAAE,UAAU,aAAa;CAC/B,MAAMG,SAAkC,EAAE;AAE1C,MAAK,MAAM,CAAC,UAAU,cAAc,OAAO,QAAQ,SAAS,MAAM,CAChE,QAAO,YAAY,IAAI,oBACrB,UACA,WACA,SACD;AAGH,QAAO"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@prisma-next/mongo-orm",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "MongoDB ORM client for Prisma Next",
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
+  },
+  "dependencies": {
+    "@prisma-next/contract": "workspace:*",
+    "@prisma-next/mongo-core": "workspace:*",
+    "@prisma-next/runtime-executor": "workspace:*"
+  },
+  "devDependencies": {
+    "@prisma-next/test-utils": "workspace:*",
+    "@prisma-next/tsconfig": "workspace:*",
+    "@prisma-next/tsdown": "workspace:*",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/2-mongo-family/4-orm"
+  }
+}

package/src/exports/index.ts

@@ -0,0 +1,15 @@
+export { mongoOrm } from '../mongo-orm';
+export type {
+  EmbedRelationKeys,
+  IncludeResultFields,
+  InferFullRow,
+  InferRootRow,
+  MongoCollection,
+  MongoFindManyOptions,
+  MongoIncludeSpec,
+  MongoOrmClient,
+  MongoOrmOptions,
+  MongoQueryExecutor,
+  MongoWhereFilter,
+  ReferenceRelationKeys,
+} from '../types';

package/src/mongo-orm.ts

@@ -0,0 +1,145 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import {
+  AggregateCommand,
+  FindCommand,
+  type MongoContract,
+  type MongoContractWithTypeMaps,
+  type MongoExpr,
+  type MongoModelDefinition,
+  type MongoQueryPlan,
+  type MongoReferenceRelation,
+  type MongoTypeMaps,
+} from '@prisma-next/mongo-core';
+import type { AsyncIterableResult } from '@prisma-next/runtime-executor';
+import type {
+  MongoFindManyOptions,
+  MongoIncludeSpec,
+  MongoOrmClient,
+  MongoOrmOptions,
+  MongoQueryExecutor,
+} from './types';
+
+const stubMeta: PlanMeta = {
+  target: 'mongo',
+  storageHash: 'orm',
+  lane: 'mongo-orm',
+  paramDescriptors: [],
+};
+
+function resolveCollection(model: MongoModelDefinition, modelName: string): string {
+  return model.storage.collection ?? modelName;
+}
+
+function buildLookupStages(
+  contract: MongoContract,
+  model: MongoModelDefinition,
+  include: Record<string, true>,
+): Record<string, unknown>[] {
+  const stages: Record<string, unknown>[] = [];
+
+  for (const [relName, shouldInclude] of Object.entries(include)) {
+    if (!shouldInclude) continue;
+
+    const relation = model.relations[relName];
+    if (!relation || relation.strategy !== 'reference') continue;
+
+    const refRelation = relation as MongoReferenceRelation;
+
+    if (refRelation.on.localFields.length !== 1 || refRelation.on.targetFields.length !== 1) {
+      throw new Error(
+        `Compound references are not yet supported: relation "${relName}" has ${refRelation.on.localFields.length} local field(s) and ${refRelation.on.targetFields.length} target field(s)`,
+      );
+    }
+
+    const targetModel = contract.models[refRelation.to];
+    if (!targetModel) continue;
+
+    const targetCollection = resolveCollection(targetModel, refRelation.to);
+
+    stages.push({
+      $lookup: {
+        from: targetCollection,
+        localField: refRelation.on.localFields[0],
+        foreignField: refRelation.on.targetFields[0],
+        as: relName,
+      },
+    });
+
+    if (refRelation.cardinality === 'N:1' || refRelation.cardinality === '1:1') {
+      stages.push({
+        $unwind: {
+          path: `$${relName}`,
+          preserveNullAndEmptyArrays: true,
+        },
+      });
+    }
+  }
+
+  return stages;
+}
+
+class MongoCollectionImpl<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> {
+  readonly #contract: TContract;
+  readonly #modelName: ModelName;
+  readonly #executor: MongoQueryExecutor;
+
+  constructor(contract: TContract, modelName: ModelName, executor: MongoQueryExecutor) {
+    this.#contract = contract;
+    this.#modelName = modelName;
+    this.#executor = executor;
+  }
+
+  findMany<TInclude extends MongoIncludeSpec<TContract, ModelName> = Record<string, never>>(
+    options?: MongoFindManyOptions<TContract, ModelName, TInclude>,
+  ): AsyncIterableResult<unknown> {
+    const model = this.#contract.models[this.#modelName] as MongoModelDefinition;
+    const collection = resolveCollection(model, this.#modelName as string);
+    const filter = options?.where ? (options.where as unknown as MongoExpr) : undefined;
+    const include = options?.include as Record<string, true> | undefined;
+
+    const hasIncludes = include && Object.keys(include).length > 0;
+
+    let plan: MongoQueryPlan;
+    if (hasIncludes) {
+      const pipeline: Record<string, unknown>[] = [];
+
+      if (filter && Object.keys(filter as Record<string, unknown>).length > 0) {
+        pipeline.push({ $match: filter });
+      }
+
+      pipeline.push(...buildLookupStages(this.#contract, model, include));
+
+      plan = {
+        command: new AggregateCommand(collection, pipeline),
+        meta: stubMeta,
+      };
+    } else {
+      plan = {
+        command: new FindCommand(collection, filter),
+        meta: stubMeta,
+      };
+    }
+
+    return this.#executor.execute(plan);
+  }
+}
+
+export function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(
+  options: MongoOrmOptions<TContract>,
+): MongoOrmClient<TContract> {
+  const { contract, executor } = options;
+  const client: Record<string, unknown> = {};
+
+  for (const [rootName, modelName] of Object.entries(contract.roots)) {
+    client[rootName] = new MongoCollectionImpl(
+      contract,
+      modelName as string & keyof TContract['models'],
+      executor,
+    );
+  }
+
+  return client as MongoOrmClient<TContract>;
+}

package/src/types.ts

@@ -0,0 +1,181 @@
+import type {
+  ExtractMongoCodecTypes,
+  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;
+}
+
+type Simplify<T> = T extends unknown ? { [K in keyof T]: T[K] } : never;
+
+// --- Relation type helpers ---
+
+export type ReferenceRelationKeys<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends {
+    readonly strategy: 'reference';
+  }
+    ? K
+    : never;
+}[keyof TContract['models'][ModelName]['relations']];
+
+export type EmbedRelationKeys<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['relations']]: TContract['models'][ModelName]['relations'][K] extends {
+    readonly strategy: 'embed';
+  }
+    ? K
+    : never;
+}[keyof TContract['models'][ModelName]['relations']];
+
+// --- Embedded field types ---
+
+type EmbedRelationRowType<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  RelKey extends keyof TContract['models'][ModelName]['relations'],
+> = TContract['models'][ModelName]['relations'][RelKey] extends {
+  readonly to: infer To extends string & keyof TContract['models'];
+  readonly cardinality: infer C;
+  readonly strategy: 'embed';
+}
+  ? C extends '1:N'
+    ? InferModelRow<TContract, To>[]
+    : InferModelRow<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> & {
+      -readonly [K in EmbedRelationKeys<TContract, ModelName> &
+        keyof TContract['models'][ModelName]['relations']]: EmbedRelationRowType<
+        TContract,
+        ModelName,
+        K
+      >;
+    };
+
+// --- Polymorphic row type ---
+
+type VariantRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = TContract['models'][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']
+          ? Simplify<
+              Omit<InferFullRow<TContract, ModelName>, DiscField> &
+                InferFullRow<TContract, VK> &
+                Record<DiscField, V[VK]['value']>
+            >
+          : never;
+      }[keyof V]
+    : InferFullRow<TContract, ModelName>
+  : InferFullRow<TContract, ModelName>;
+
+export type InferRootRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = VariantRow<TContract, ModelName>;
+
+// --- Include result type augmentation ---
+
+type IncludeRelationRowType<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  RelKey extends keyof TContract['models'][ModelName]['relations'],
+> = TContract['models'][ModelName]['relations'][RelKey] extends {
+  readonly to: infer To extends string & keyof TContract['models'];
+  readonly cardinality: infer C;
+  readonly strategy: 'reference';
+}
+  ? C extends 'N:1' | '1:1'
+    ? InferFullRow<TContract, To> | null
+    : InferFullRow<TContract, To>[]
+  : never;
+
+export type IncludeResultFields<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  TInclude extends MongoIncludeSpec<TContract, ModelName>,
+> = {
+  -readonly [K in keyof TInclude & string as TInclude[K] extends true
+    ? K
+    : never]: K extends keyof TContract['models'][ModelName]['relations']
+    ? IncludeRelationRowType<TContract, ModelName, K>
+    : never;
+};
+
+// --- Query options ---
+
+export type MongoWhereFilter<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  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;
+  }
+    ? TCodecTypes[CId]['output']
+    : unknown;
+};
+
+export type MongoIncludeSpec<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  readonly [K in ReferenceRelationKeys<TContract, ModelName>]?: true;
+};
+
+export interface MongoFindManyOptions<
+  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;
+}
+
+// --- Client types ---
+
+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;
+};
+
+export interface MongoCollection<
+  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>
+  >;
+}