@prisma/orm-family-mongo 0.16.0-dev.36

package/dist/filter-expressions-Uo8ZdzwB-53qnqceS.mjs

@@ -0,0 +1,181 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+//#region ../../../2-mongo-family/4-query/query-ast/dist/filter-expressions-Uo8ZdzwB.mjs
+var MongoAstNode = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function ormError(code, message, options) {
+	return structuredError(code, message, options);
+}
+const FILTER_EXPR_BRAND = "__prismaNextMongoFilter__";
+function isMongoFilterExpr(value) {
+	return typeof value === "object" && value !== null && FILTER_EXPR_BRAND in value;
+}
+var MongoFilterExpression = class extends MongoAstNode {
+	not() {
+		return new MongoNotExpr(this);
+	}
+	and(other) {
+		return MongoAndExpr.of([this, other]);
+	}
+};
+Object.defineProperty(MongoFilterExpression.prototype, FILTER_EXPR_BRAND, {
+	value: true,
+	writable: false,
+	enumerable: false,
+	configurable: false
+});
+var MongoFieldFilter = class MongoFieldFilter extends MongoFilterExpression {
+	kind = "field";
+	field;
+	op;
+	value;
+	constructor(field, op, value) {
+		super();
+		this.field = field;
+		this.op = op;
+		this.value = value;
+		this.freeze();
+	}
+	static of(field, op, value) {
+		return new MongoFieldFilter(field, op, value);
+	}
+	static eq(field, value) {
+		return new MongoFieldFilter(field, "$eq", value);
+	}
+	static neq(field, value) {
+		return new MongoFieldFilter(field, "$ne", value);
+	}
+	static gt(field, value) {
+		return new MongoFieldFilter(field, "$gt", value);
+	}
+	static lt(field, value) {
+		return new MongoFieldFilter(field, "$lt", value);
+	}
+	static gte(field, value) {
+		return new MongoFieldFilter(field, "$gte", value);
+	}
+	static lte(field, value) {
+		return new MongoFieldFilter(field, "$lte", value);
+	}
+	static in(field, values) {
+		return new MongoFieldFilter(field, "$in", values);
+	}
+	static nin(field, values) {
+		return new MongoFieldFilter(field, "$nin", values);
+	}
+	static isNull(field) {
+		return new MongoFieldFilter(field, "$eq", null);
+	}
+	static isNotNull(field) {
+		return new MongoFieldFilter(field, "$ne", null);
+	}
+	accept(visitor) {
+		return visitor.field(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.field ? rewriter.field(this) : this;
+	}
+};
+var MongoAndExpr = class MongoAndExpr extends MongoFilterExpression {
+	kind = "and";
+	exprs;
+	constructor(exprs) {
+		super();
+		if (exprs.length === 0) throw ormError("ORM.ARGUMENT_INVALID", "$and requires at least one expression");
+		this.exprs = Object.freeze([...exprs]);
+		this.freeze();
+	}
+	static of(exprs) {
+		return new MongoAndExpr(exprs);
+	}
+	accept(visitor) {
+		return visitor.and(this);
+	}
+	rewrite(rewriter) {
+		const rewritten = new MongoAndExpr(this.exprs.map((e) => e.rewrite(rewriter)));
+		return rewriter.and ? rewriter.and(rewritten) : rewritten;
+	}
+};
+var MongoOrExpr = class MongoOrExpr extends MongoFilterExpression {
+	kind = "or";
+	exprs;
+	constructor(exprs) {
+		super();
+		if (exprs.length === 0) throw ormError("ORM.ARGUMENT_INVALID", "$or requires at least one expression");
+		this.exprs = Object.freeze([...exprs]);
+		this.freeze();
+	}
+	static of(exprs) {
+		return new MongoOrExpr(exprs);
+	}
+	accept(visitor) {
+		return visitor.or(this);
+	}
+	rewrite(rewriter) {
+		const rewritten = new MongoOrExpr(this.exprs.map((e) => e.rewrite(rewriter)));
+		return rewriter.or ? rewriter.or(rewritten) : rewritten;
+	}
+};
+var MongoNotExpr = class MongoNotExpr extends MongoFilterExpression {
+	kind = "not";
+	expr;
+	constructor(expr) {
+		super();
+		this.expr = expr;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.not(this);
+	}
+	rewrite(rewriter) {
+		const rewritten = new MongoNotExpr(this.expr.rewrite(rewriter));
+		return rewriter.not ? rewriter.not(rewritten) : rewritten;
+	}
+};
+var MongoExistsExpr = class MongoExistsExpr extends MongoFilterExpression {
+	kind = "exists";
+	field;
+	exists;
+	constructor(field, exists) {
+		super();
+		this.field = field;
+		this.exists = exists;
+		this.freeze();
+	}
+	static exists(field) {
+		return new MongoExistsExpr(field, true);
+	}
+	static notExists(field) {
+		return new MongoExistsExpr(field, false);
+	}
+	accept(visitor) {
+		return visitor.exists(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.exists ? rewriter.exists(this) : this;
+	}
+};
+var MongoExprFilter = class MongoExprFilter extends MongoFilterExpression {
+	kind = "expr";
+	aggExpr;
+	constructor(aggExpr) {
+		super();
+		this.aggExpr = aggExpr;
+		this.freeze();
+	}
+	static of(aggExpr) {
+		return new MongoExprFilter(aggExpr);
+	}
+	accept(visitor) {
+		return visitor.expr(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.expr ? rewriter.expr(this) : this;
+	}
+};
+//#endregion
+export { MongoFieldFilter as a, isMongoFilterExpr as c, MongoExprFilter as i, ormError as l, MongoAstNode as n, MongoNotExpr as o, MongoExistsExpr as r, MongoOrExpr as s, MongoAndExpr as t };
+
+//# sourceMappingURL=filter-expressions-Uo8ZdzwB-53qnqceS.mjs.map

package/dist/filter-expressions-Uo8ZdzwB-53qnqceS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-expressions-Uo8ZdzwB-53qnqceS.mjs","names":[],"sources":["../../../../2-mongo-family/4-query/query-ast/dist/filter-expressions-Uo8ZdzwB.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\n//#region src/ast-node.ts\nvar MongoAstNode = class {\n\tfreeze() {\n\t\tObject.freeze(this);\n\t}\n};\n//#endregion\n//#region src/orm-errors.ts\nfunction ormError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n//#endregion\n//#region src/filter-expressions.ts\nconst FILTER_EXPR_BRAND = \"__prismaNextMongoFilter__\";\nfunction isMongoFilterExpr(value) {\n\treturn typeof value === \"object\" && value !== null && FILTER_EXPR_BRAND in value;\n}\nvar MongoFilterExpression = class extends MongoAstNode {\n\tnot() {\n\t\treturn new MongoNotExpr(this);\n\t}\n\tand(other) {\n\t\treturn MongoAndExpr.of([this, other]);\n\t}\n};\nObject.defineProperty(MongoFilterExpression.prototype, FILTER_EXPR_BRAND, {\n\tvalue: true,\n\twritable: false,\n\tenumerable: false,\n\tconfigurable: false\n});\nvar MongoFieldFilter = class MongoFieldFilter extends MongoFilterExpression {\n\tkind = \"field\";\n\tfield;\n\top;\n\tvalue;\n\tconstructor(field, op, value) {\n\t\tsuper();\n\t\tthis.field = field;\n\t\tthis.op = op;\n\t\tthis.value = value;\n\t\tthis.freeze();\n\t}\n\tstatic of(field, op, value) {\n\t\treturn new MongoFieldFilter(field, op, value);\n\t}\n\tstatic eq(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$eq\", value);\n\t}\n\tstatic neq(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$ne\", value);\n\t}\n\tstatic gt(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$gt\", value);\n\t}\n\tstatic lt(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$lt\", value);\n\t}\n\tstatic gte(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$gte\", value);\n\t}\n\tstatic lte(field, value) {\n\t\treturn new MongoFieldFilter(field, \"$lte\", value);\n\t}\n\tstatic in(field, values) {\n\t\treturn new MongoFieldFilter(field, \"$in\", values);\n\t}\n\tstatic nin(field, values) {\n\t\treturn new MongoFieldFilter(field, \"$nin\", values);\n\t}\n\tstatic isNull(field) {\n\t\treturn new MongoFieldFilter(field, \"$eq\", null);\n\t}\n\tstatic isNotNull(field) {\n\t\treturn new MongoFieldFilter(field, \"$ne\", null);\n\t}\n\taccept(visitor) {\n\t\treturn visitor.field(this);\n\t}\n\trewrite(rewriter) {\n\t\treturn rewriter.field ? rewriter.field(this) : this;\n\t}\n};\nvar MongoAndExpr = class MongoAndExpr extends MongoFilterExpression {\n\tkind = \"and\";\n\texprs;\n\tconstructor(exprs) {\n\t\tsuper();\n\t\tif (exprs.length === 0) throw ormError(\"ORM.ARGUMENT_INVALID\", \"$and requires at least one expression\");\n\t\tthis.exprs = Object.freeze([...exprs]);\n\t\tthis.freeze();\n\t}\n\tstatic of(exprs) {\n\t\treturn new MongoAndExpr(exprs);\n\t}\n\taccept(visitor) {\n\t\treturn visitor.and(this);\n\t}\n\trewrite(rewriter) {\n\t\tconst rewritten = new MongoAndExpr(this.exprs.map((e) => e.rewrite(rewriter)));\n\t\treturn rewriter.and ? rewriter.and(rewritten) : rewritten;\n\t}\n};\nvar MongoOrExpr = class MongoOrExpr extends MongoFilterExpression {\n\tkind = \"or\";\n\texprs;\n\tconstructor(exprs) {\n\t\tsuper();\n\t\tif (exprs.length === 0) throw ormError(\"ORM.ARGUMENT_INVALID\", \"$or requires at least one expression\");\n\t\tthis.exprs = Object.freeze([...exprs]);\n\t\tthis.freeze();\n\t}\n\tstatic of(exprs) {\n\t\treturn new MongoOrExpr(exprs);\n\t}\n\taccept(visitor) {\n\t\treturn visitor.or(this);\n\t}\n\trewrite(rewriter) {\n\t\tconst rewritten = new MongoOrExpr(this.exprs.map((e) => e.rewrite(rewriter)));\n\t\treturn rewriter.or ? rewriter.or(rewritten) : rewritten;\n\t}\n};\nvar MongoNotExpr = class MongoNotExpr extends MongoFilterExpression {\n\tkind = \"not\";\n\texpr;\n\tconstructor(expr) {\n\t\tsuper();\n\t\tthis.expr = expr;\n\t\tthis.freeze();\n\t}\n\taccept(visitor) {\n\t\treturn visitor.not(this);\n\t}\n\trewrite(rewriter) {\n\t\tconst rewritten = new MongoNotExpr(this.expr.rewrite(rewriter));\n\t\treturn rewriter.not ? rewriter.not(rewritten) : rewritten;\n\t}\n};\nvar MongoExistsExpr = class MongoExistsExpr extends MongoFilterExpression {\n\tkind = \"exists\";\n\tfield;\n\texists;\n\tconstructor(field, exists) {\n\t\tsuper();\n\t\tthis.field = field;\n\t\tthis.exists = exists;\n\t\tthis.freeze();\n\t}\n\tstatic exists(field) {\n\t\treturn new MongoExistsExpr(field, true);\n\t}\n\tstatic notExists(field) {\n\t\treturn new MongoExistsExpr(field, false);\n\t}\n\taccept(visitor) {\n\t\treturn visitor.exists(this);\n\t}\n\trewrite(rewriter) {\n\t\treturn rewriter.exists ? rewriter.exists(this) : this;\n\t}\n};\nvar MongoExprFilter = class MongoExprFilter extends MongoFilterExpression {\n\tkind = \"expr\";\n\taggExpr;\n\tconstructor(aggExpr) {\n\t\tsuper();\n\t\tthis.aggExpr = aggExpr;\n\t\tthis.freeze();\n\t}\n\tstatic of(aggExpr) {\n\t\treturn new MongoExprFilter(aggExpr);\n\t}\n\taccept(visitor) {\n\t\treturn visitor.expr(this);\n\t}\n\trewrite(rewriter) {\n\t\treturn rewriter.expr ? rewriter.expr(this) : this;\n\t}\n};\n//#endregion\nexport { MongoNotExpr as a, ormError as c, MongoFieldFilter as i, MongoAstNode as l, MongoExistsExpr as n, MongoOrExpr as o, MongoExprFilter as r, isMongoFilterExpr as s, MongoAndExpr as t };\n\n//# sourceMappingURL=filter-expressions-Uo8ZdzwB.mjs.map"],"mappings":"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"}

package/dist/index-BR0ue13b.d.mts

@@ -0,0 +1,136 @@
+import { n as CreateCollectionOptions, r as CreateIndexesOptions, t as CollationOptions } from "./mongodb-types-B4HmhF1S.mjs";
+import { j as MongoIndexKeyDirection } from "./mongo-value-set-tNn9-pun-dJYx_rVD.mjs";
+import { l as RawPipeline, t as Document } from "./index-wKMm41HC.mjs";
+import { a as CollModOptions, l as CreateIndexOptions, s as CreateCollectionOptions$1 } from "./control-C7-kthr1.mjs";
+import "./execution-CKnUiOfm.mjs";
+//#region ../../../2-mongo-family/6-transport/mongo-wire/dist/index.d.mts
+//#region src/wire-commands.d.ts
+declare abstract class MongoWireCommand {
+  abstract readonly kind: string;
+  readonly collection: string;
+  protected constructor(collection: string);
+  protected freeze(): void;
+}
+declare class InsertOneWireCommand extends MongoWireCommand {
+  readonly kind: "insertOne";
+  readonly document: Document;
+  constructor(collection: string, document: Document);
+}
+declare class UpdateOneWireCommand extends MongoWireCommand {
+  readonly kind: "updateOne";
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  readonly upsert: boolean;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>, upsert?: boolean);
+}
+declare class DeleteOneWireCommand extends MongoWireCommand {
+  readonly kind: "deleteOne";
+  readonly filter: Document;
+  constructor(collection: string, filter: Document);
+}
+declare class InsertManyWireCommand extends MongoWireCommand {
+  readonly kind: "insertMany";
+  readonly documents: ReadonlyArray<Document>;
+  constructor(collection: string, documents: ReadonlyArray<Document>);
+}
+declare class UpdateManyWireCommand extends MongoWireCommand {
+  readonly kind: "updateMany";
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  readonly upsert: boolean;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>, upsert?: boolean);
+}
+declare class DeleteManyWireCommand extends MongoWireCommand {
+  readonly kind: "deleteMany";
+  readonly filter: Document;
+  constructor(collection: string, filter: Document);
+}
+declare class FindOneAndUpdateWireCommand extends MongoWireCommand {
+  readonly kind: "findOneAndUpdate";
+  readonly filter: Document;
+  readonly update: Document | ReadonlyArray<Document>;
+  readonly upsert: boolean;
+  readonly sort: Record<string, 1 | -1> | undefined;
+  /**
+   * When `undefined`, the option is omitted from the underlying driver
+   * call so Mongo's documented default (pre-image document) applies.
+   */
+  readonly returnDocument: 'before' | 'after' | undefined;
+  constructor(collection: string, filter: Document, update: Document | ReadonlyArray<Document>, upsert?: boolean, sort?: Record<string, 1 | -1>, returnDocument?: 'before' | 'after');
+}
+declare class FindOneAndDeleteWireCommand extends MongoWireCommand {
+  readonly kind: "findOneAndDelete";
+  readonly filter: Document;
+  readonly sort: Record<string, 1 | -1> | undefined;
+  constructor(collection: string, filter: Document, sort?: Record<string, 1 | -1>);
+}
+declare class AggregateWireCommand extends MongoWireCommand {
+  readonly kind: "aggregate";
+  readonly pipeline: RawPipeline;
+  constructor(collection: string, pipeline: RawPipeline);
+}
+declare class CreateCollectionWireCommand extends MongoWireCommand implements CreateCollectionOptions {
+  readonly kind: "createCollection";
+  readonly validator?: Record<string, unknown>;
+  readonly validationLevel?: 'strict' | 'moderate';
+  readonly validationAction?: 'error' | 'warn';
+  readonly capped?: boolean;
+  readonly size?: number;
+  readonly max?: number;
+  readonly timeseries?: {
+    timeField: string;
+    metaField?: string;
+    granularity?: 'seconds' | 'minutes' | 'hours';
+  };
+  readonly collation?: CollationOptions;
+  readonly changeStreamPreAndPostImages?: {
+    enabled: boolean;
+  };
+  readonly clusteredIndex?: {
+    key: Record<string, number>;
+    unique: boolean;
+    name?: string;
+  };
+  constructor(collection: string, options: CreateCollectionOptions$1);
+}
+declare class CreateIndexWireCommand extends MongoWireCommand implements CreateIndexesOptions {
+  readonly kind: "createIndex";
+  readonly key: Record<string, MongoIndexKeyDirection>;
+  readonly unique?: boolean;
+  readonly sparse?: boolean;
+  readonly expireAfterSeconds?: number;
+  readonly partialFilterExpression?: Record<string, unknown>;
+  readonly name?: string;
+  readonly wildcardProjection?: Record<string, 0 | 1>;
+  readonly collation?: CollationOptions;
+  readonly weights?: Record<string, number>;
+  readonly default_language?: string;
+  readonly language_override?: string;
+  constructor(collection: string, key: Record<string, MongoIndexKeyDirection>, options: CreateIndexOptions);
+}
+declare class DropCollectionWireCommand extends MongoWireCommand {
+  readonly kind: "dropCollection";
+  constructor(collection: string);
+}
+declare class DropIndexWireCommand extends MongoWireCommand {
+  readonly kind: "dropIndex";
+  readonly name: string;
+  constructor(collection: string, name: string);
+}
+declare class CollModWireCommand extends MongoWireCommand {
+  readonly kind: "collMod";
+  readonly validator?: Record<string, unknown>;
+  readonly validationLevel?: 'strict' | 'moderate';
+  readonly validationAction?: 'error' | 'warn';
+  readonly changeStreamPreAndPostImages?: {
+    enabled: boolean;
+  };
+  constructor(collection: string, options: CollModOptions);
+}
+type AnyMongoDmlWireCommand = InsertOneWireCommand | InsertManyWireCommand | UpdateOneWireCommand | UpdateManyWireCommand | DeleteOneWireCommand | DeleteManyWireCommand | FindOneAndUpdateWireCommand | FindOneAndDeleteWireCommand | AggregateWireCommand;
+type AnyMongoDdlWireCommand = CreateCollectionWireCommand | CreateIndexWireCommand | DropCollectionWireCommand | DropIndexWireCommand | CollModWireCommand;
+type AnyMongoWireCommand = AnyMongoDmlWireCommand | AnyMongoDdlWireCommand;
+declare function isDdlWireCommand(cmd: AnyMongoWireCommand): cmd is AnyMongoDdlWireCommand;
+//#endregion
+export { UpdateOneWireCommand as _, CollModWireCommand as a, DeleteManyWireCommand as c, DropIndexWireCommand as d, FindOneAndDeleteWireCommand as f, UpdateManyWireCommand as g, InsertOneWireCommand as h, AnyMongoWireCommand as i, DeleteOneWireCommand as l, InsertManyWireCommand as m, AnyMongoDdlWireCommand as n, CreateCollectionWireCommand as o, FindOneAndUpdateWireCommand as p, AnyMongoDmlWireCommand as r, CreateIndexWireCommand as s, AggregateWireCommand as t, DropCollectionWireCommand as u, isDdlWireCommand as v };
+//# sourceMappingURL=index-BR0ue13b.d.mts.map

package/dist/index-BR0ue13b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BR0ue13b.d.mts","names":[],"sources":["../../../../2-mongo-family/6-transport/mongo-wire/dist/index.d.mts"],"mappings":";;;;;;;uBAKuB;oBACH;WACT;YACC,YAAY;YACZ;;cAEE,6BAA6B;WAChC;WACA,UAAU;EACnB,YAAY,oBAAoB,UAAU;;cAE9B,6BAA6B;WAChC;WACA,QAAQ;WACR,QAAQ,WAAW,cAAc;WACjC;EACT,YAAY,oBAAoB,QAAQ,UAAU,QAAQ,WAAW,cAAc,WAAW;;cAElF,6BAA6B;WAChC;WACA,QAAQ;EACjB,YAAY,oBAAoB,QAAQ;;cAE5B,8BAA8B;WACjC;WACA,WAAW,cAAc;EAClC,YAAY,oBAAoB,WAAW,cAAc;;cAE7C,8BAA8B;WACjC;WACA,QAAQ;WACR,QAAQ,WAAW,cAAc;WACjC;EACT,YAAY,oBAAoB,QAAQ,UAAU,QAAQ,WAAW,cAAc,WAAW;;cAElF,8BAA8B;WACjC;WACA,QAAQ;EACjB,YAAY,oBAAoB,QAAQ;;cAE5B,oCAAoC;WACvC;WACA,QAAQ;WACR,QAAQ,WAAW,cAAc;WACjC;WACA,MAAM;;;;;WAKN;EACT,YAAY,oBAAoB,QAAQ,UAAU,QAAQ,WAAW,cAAc,WAAW,kBAAkB,OAAO,wBAAwB;;cAEnI,oCAAoC;WACvC;WACA,QAAQ;WACR,MAAM;EACf,YAAY,oBAAoB,QAAQ,UAAU,OAAO;;cAE7C,6BAA6B;WAChC;WACA,UAAU;EACnB,YAAY,oBAAoB,UAAU;;cAE9B,oCAAoC,4BAA4B;WACnE;WACA,YAAY;WACZ;WACA;WACA;WACA;WACA;WACA;IACP;IACA;IACA;;WAEO,YAAY;WACZ;IACP;;WAEO;IACP,KAAK;IACL;IACA;;EAEF,YAAY,oBAAoB,SAAS;;cAE7B,+BAA+B,4BAA4B;WAC9D;WACA,KAAK,eAAe;WACpB;WACA;WACA;WACA,0BAA0B;WAC1B;WACA,qBAAqB;WACrB,YAAY;WACZ,UAAU;WACV;WACA;EACT,YAAY,oBAAoB,KAAK,eAAe,yBAAyB,SAAS;;cAE1E,kCAAkC;WACrC;EACT,YAAY;;cAEA,6BAA6B;WAChC;WACA;EACT,YAAY,oBAAoB;;cAEpB,2BAA2B;WAC9B;WACA,YAAY;WACZ;WACA;WACA;IACP;;EAEF,YAAY,oBAAoB,SAAS;;KAEtC,yBAAyB,uBAAuB,wBAAwB,uBAAuB,wBAAwB,uBAAuB,wBAAwB,8BAA8B,8BAA8B;KAClO,yBAAyB,8BAA8B,yBAAyB,4BAA4B,uBAAuB;KACnI,sBAAsB,yBAAyB;iBACnC,iBAAiB,KAAK,sBAAsB,OAAO"}

package/dist/index-Cd2zLiU6.d.mts

@@ -0,0 +1,128 @@
+import { C as MongoContract, T as MongoIndex, nt as MongoValueSet, rt as MongoValueSetInput, v as MongoCollection, y as MongoCollectionInput } from "./mongo-value-set-tNn9-pun-dJYx_rVD.mjs";
+import { StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { Type } from "arktype";
+import { DefaultNamespaceEntries, IRNodeBase, Namespace, NamespaceBase, NamespacedEntities, SingleNamespaceView, Storage } from "@prisma/orm-framework/components/ir";
+//#region ../../../2-mongo-family/1-foundation/mongo-contract/dist/index.d.mts
+//#region src/contract-schema.d.ts
+declare const StorageValueSetSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  kind: "valueSet";
+  values: readonly (string | number | boolean | Record<string, unknown> | unknown[] | null)[];
+}, {}>;
+/**
+ * Builds the per-namespace envelope schema for Mongo storage. Pack
+ * contributions are keyed by the descriptor's `discriminator` and
+ * validate each entry by matching the entry's `kind` field. Mongo today
+ * has no pack contributions; the composition surface exists for symmetry
+ * with SQL and as the substrate for future entity kinds.
+ *
+ * `'kind?': 'string'` because `kind` is non-enumerable on built
+ * Mongo namespace IR classes and therefore absent from the wire shape; the
+ * type-side narrowing is enforced by the IR class, not by this validator.
+ */
+declare function createMongoNamespaceEnvelopeSchema(fragments?: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
+/**
+ * Builds the full Mongo contract schema. The per-namespace entry
+ * threading happens through {@link createMongoNamespaceEnvelopeSchema};
+ * the rest of the envelope is family-shared.
+ */
+declare function createMongoContractSchema(fragments?: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
+declare const MongoContractSchema: import("arktype").BaseType<unknown, {}>;
+//#endregion
+//#region src/contract-view.d.ts
+declare const MONGO_BUILTIN_KINDS: readonly ["collection"];
+type MongoBuiltinKind = (typeof MONGO_BUILTIN_KINDS)[number];
+type MongoEntries<TContract extends MongoContract> = DefaultNamespaceEntries<TContract['storage']>;
+/**
+ * The Mongo accessors: the built-in `collection` kind promoted to a top-level
+ * accessor, pack-contributed kinds under `entries` (singular keys).
+ */
+type MongoContractAccessors<TContract extends MongoContract> = SingleNamespaceView<MongoEntries<TContract>, MongoBuiltinKind>;
+/**
+ * A Mongo contract view: the deserialized contract intersected with the by-name
+ * accessors, so the value is substitutable for `Contract` (carries `storage`,
+ * `domain`, …) while also exposing:
+ *  - `view.collection.<name>` — the built-in kind, sole namespace unwrapped to
+ *    the root (Mongo is single-namespace).
+ *  - `view.entries.<kind>` — pack-contributed kinds (singular keys).
+ *  - `view.namespace.<id>` — the namespace-keyed entity map (Mongo's sole
+ *    namespace is `__unbound__`). This mirrors the runtime `db.enums` pattern:
+ *    a single fixed `namespace` member, collision-proof.
+ *
+ * The factory (`MongoContractView.from` / `.fromJson`) lives in
+ * `@internal/family-mongo/ir`, where the Mongo serializer is reachable; this
+ * package owns the serializer-agnostic projection type and builder.
+ */
+type MongoContractView<TContract extends MongoContract = MongoContract> = TContract & MongoContractAccessors<TContract> & {
+  readonly namespace: NamespacedEntities<TContract['storage'], MongoBuiltinKind>;
+};
+/**
+ * Builds the Mongo view: unwraps the sole namespace's built-in `collection` kind
+ * to the root, attaches the namespace-keyed `namespace` map, and layers both
+ * over the deserialized contract so the result is a structural superset of the
+ * contract.
+ */
+declare function buildMongoContractView<TContract extends MongoContract>(contract: TContract): MongoContractView<TContract>;
+//#endregion
+//#region src/default-namespace.d.ts
+/** Default storage namespace for Mongo-family contracts at runtime. */
+declare const defaultMongoStorageNamespaceId: "__unbound__";
+/** Default domain namespace for Mongo-family contracts at runtime. */
+declare const defaultMongoDomainNamespaceId: "__unbound__";
+//#endregion
+//#region src/ir/mongo-storage.d.ts
+type MongoNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+  readonly collection?: Readonly<Record<string, MongoCollection>>;
+  readonly valueSet?: Readonly<Record<string, MongoValueSet>>;
+};
+interface MongoNamespaceCollectionsInput {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+    readonly collection?: Readonly<Record<string, MongoCollectionInput>>;
+    readonly valueSet?: Readonly<Record<string, MongoValueSetInput>>;
+  };
+}
+type MongoNamespace = Namespace & {
+  readonly entries: MongoNamespaceEntries;
+};
+interface MongoStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, MongoNamespace>>;
+}
+declare class MongoStorage<THash extends string = string> extends IRNodeBase implements Storage {
+  readonly kind: 'mongo-storage';
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, MongoNamespace>>;
+  constructor(input: MongoStorageInput<THash>);
+}
+//#endregion
+//#region src/ir/build-mongo-namespace.d.ts
+declare function buildMongoNamespace(input: MongoNamespaceCollectionsInput): MongoNamespace;
+//#endregion
+//#region src/ir/mongo-unbound-namespace.d.ts
+declare class MongoUnboundNamespace extends NamespaceBase {
+  static readonly instance: MongoUnboundNamespace;
+  readonly id: "__unbound__";
+  readonly entries: MongoNamespaceEntries;
+  readonly kind: string;
+  private constructor();
+}
+//#endregion
+//#region src/polymorphic-index-scope.d.ts
+type PolymorphicIndexScope = {
+  readonly discriminatorField: string;
+  readonly discriminatorValue: string | number | boolean;
+};
+type ApplyScopeResult = {
+  readonly kind: 'ok';
+  readonly index: MongoIndex;
+} | {
+  readonly kind: 'conflict';
+  readonly reason: string;
+};
+declare function applyPolymorphicScopeToMongoIndex(index: MongoIndex, scope: PolymorphicIndexScope): ApplyScopeResult;
+//#endregion
+//#region src/validate-storage.d.ts
+declare function validateMongoStorage(contract: MongoContract): void;
+//#endregion
+export { defaultMongoDomainNamespaceId as _, MongoNamespace as a, MongoStorageInput as c, StorageValueSetSchema as d, applyPolymorphicScopeToMongoIndex as f, createMongoNamespaceEnvelopeSchema as g, createMongoContractSchema as h, MongoContractView as i, MongoUnboundNamespace as l, buildMongoNamespace as m, MongoContractAccessors as n, MongoNamespaceEntries as o, buildMongoContractView as p, MongoContractSchema as r, MongoStorage as s, ApplyScopeResult as t, PolymorphicIndexScope as u, defaultMongoStorageNamespaceId as v, validateMongoStorage as y };
+//# sourceMappingURL=index-Cd2zLiU6.d.mts.map

package/dist/index-Cd2zLiU6.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Cd2zLiU6.d.mts","names":[],"sources":["../../../../2-mongo-family/1-foundation/mongo-contract/dist/index.d.mts"],"mappings":";;;;;;cAKc,qEAAqE;EACjF;EACA,8CAA8C;;;;;;;;;;;;;iBAa/B,mCAAmC,YAAY,oBAAoB,iBAAiB;;;;;;iBAMpF,0BAA0B,YAAY,oBAAoB,iBAAiB;cAC9E,uCAAuC;;;cAGvC;KACT,2BAA2B;KAC3B,aAAa,kBAAkB,iBAAiB,wBAAwB;;;;;KAKxE,uBAAuB,kBAAkB,iBAAiB,oBAAoB,aAAa,YAAY;;;;;;;;;;;;;;;;KAgBvG,kBAAkB,kBAAkB,gBAAgB,iBAAiB,YAAY,uBAAuB;WAClG,WAAW,mBAAmB,sBAAsB;;;;;;;;iBAQ9C,uBAAuB,kBAAkB,eAAe,UAAU,YAAY,kBAAkB;;;;cAInG;;cAEA;;;KAGT,wBAAwB,SAAS,eAAe,SAAS;WACnD,aAAa,SAAS,eAAe;WACrC,WAAW,SAAS,eAAe;;UAEpC;WACC;WACA,SAAS,SAAS,eAAe,SAAS;aACxC,aAAa,SAAS,eAAe;aACrC,WAAW,SAAS,eAAe;;;KAG3C,iBAAiB;WACX,SAAS;;UAEV,kBAAkB;WACjB,aAAa,gBAAgB;WAC7B,YAAY,SAAS,eAAe;;cAEjC,aAAa,uCAAuC,sBAAsB;WAC7E;WACA,aAAa,gBAAgB;WAC7B,YAAY,SAAS,eAAe;EAC7C,YAAY,OAAO,kBAAkB;;;;iBAItB,oBAAoB,OAAO,iCAAiC;;;cAG/D,8BAA8B;kBAC1B,UAAU;WACjB;WACA,SAAS;WACT;UACD;;;;KAIL;WACM;WACA;;KAEN;WACM;WACA,OAAO;;WAEP;WACA;;iBAEM,kCAAkC,OAAO,YAAY,OAAO,wBAAwB;;;iBAGpF,qBAAqB,UAAU"}

package/dist/index-DAOkcTCK.d.mts

@@ -0,0 +1,151 @@
+import { rt as MongoQueryPlan } from "./query-plan-C0-Yu8hf-DdilEdW6.mjs";
+import { t as AnyMongoDdlCommand } from "./control-C7-kthr1.mjs";
+import "./execution-CKnUiOfm.mjs";
+import { i as AnyMongoWireCommand, n as AnyMongoDdlWireCommand, r as AnyMongoDmlWireCommand } from "./index-BR0ue13b.mjs";
+import { ControlDriverInstance } from "@prisma/orm-framework/components/control";
+import { CodecCallContext } from "@prisma/orm-framework/components/codec";
+import { Db } from "mongodb";
+//#region ../../../2-mongo-family/6-transport/mongo-lowering/dist/index.d.mts
+//#region src/adapter-types.d.ts
+/**
+ * Intermediate state produced by structural lowering. `MongoParamRef` leaves
+ * remain in place — they have not yet been resolved through codecs. The
+ * runtime defers value resolution past the `beforeExecute` middleware chain
+ * so middleware can walk and rewrite `MongoParamRef` nodes before encoding.
+ *
+ * All document/filter/update slots that may carry `MongoParamRef` nodes are
+ * typed as `Record<string, unknown>` to allow heterogeneous values. Raw
+ * command variants carry already-resolved `Record<string, unknown>` values
+ * and pass through unchanged.
+ */
+type MongoLoweredDraft = {
+  readonly kind: 'insertOne';
+  readonly collection: string;
+  readonly document: Record<string, unknown>;
+} | {
+  readonly kind: 'insertMany';
+  readonly collection: string;
+  readonly documents: ReadonlyArray<Record<string, unknown>>;
+} | {
+  readonly kind: 'updateOne';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+  readonly upsert: boolean | undefined;
+} | {
+  readonly kind: 'updateMany';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+  readonly upsert: boolean | undefined;
+} | {
+  readonly kind: 'deleteOne';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+} | {
+  readonly kind: 'deleteMany';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+} | {
+  readonly kind: 'findOneAndUpdate';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+  readonly upsert: boolean | undefined;
+  readonly sort: Record<string, 1 | -1> | undefined;
+  readonly returnDocument: 'before' | 'after' | undefined;
+} | {
+  readonly kind: 'findOneAndDelete';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly sort: Record<string, 1 | -1> | undefined;
+} | {
+  readonly kind: 'aggregate';
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<Record<string, unknown>>;
+} | {
+  readonly kind: 'rawInsertOne';
+  readonly collection: string;
+  readonly document: Record<string, unknown>;
+} | {
+  readonly kind: 'rawInsertMany';
+  readonly collection: string;
+  readonly documents: ReadonlyArray<Record<string, unknown>>;
+} | {
+  readonly kind: 'rawUpdateOne';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+} | {
+  readonly kind: 'rawUpdateMany';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+} | {
+  readonly kind: 'rawDeleteOne';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+} | {
+  readonly kind: 'rawDeleteMany';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+} | {
+  readonly kind: 'rawFindOneAndUpdate';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>;
+  readonly upsert: boolean;
+  readonly sort: Record<string, 1 | -1> | undefined;
+  readonly returnDocument: 'before' | 'after' | undefined;
+} | {
+  readonly kind: 'rawFindOneAndDelete';
+  readonly collection: string;
+  readonly filter: Record<string, unknown>;
+  readonly sort: Record<string, 1 | -1> | undefined;
+} | {
+  readonly kind: 'rawAggregate';
+  readonly collection: string;
+  readonly pipeline: ReadonlyArray<Record<string, unknown>>;
+};
+/** Wraps a DDL command for passage to `MongoAdapter.lower`. */
+interface MongoDdlPlan {
+  readonly command: AnyMongoDdlCommand;
+}
+interface MongoAdapter {
+  lower(plan: MongoDdlPlan, ctx: CodecCallContext): Promise<AnyMongoDdlWireCommand>;
+  lower(plan: MongoQueryPlan, ctx: CodecCallContext): Promise<AnyMongoDmlWireCommand>;
+  lower(plan: MongoQueryPlan | MongoDdlPlan, ctx: CodecCallContext): Promise<AnyMongoWireCommand>;
+  /**
+   * Phase 1 of the two-phase lowering pipeline (DML only).
+   *
+   * Transforms the plan's command AST into the lowered wire shape **without**
+   * calling `resolveValue` on any `MongoParamRef` leaf. All filter predicates,
+   * document fields, and pipeline stage values that carry `MongoParamRef`
+   * nodes are preserved in the returned `MongoLoweredDraft` so that the
+   * `beforeExecute` middleware chain can inspect and rewrite them before
+   * encoding runs. Synchronous — no I/O or codec calls.
+   */
+  structuralLower(plan: MongoQueryPlan): MongoLoweredDraft;
+  /**
+   * Phase 2 of the two-phase lowering pipeline.
+   *
+   * Walks the `MongoLoweredDraft` produced by `structuralLower`, resolves
+   * every `MongoParamRef` leaf through the codec registry, and constructs the
+   * frozen `AnyMongoWireCommand` ready for the driver. The same abort-signal
+   * forwarding and `RUNTIME.ABORTED` surface contract as `lower` applies.
+   */
+  resolveParams(draft: MongoLoweredDraft, ctx: CodecCallContext): Promise<AnyMongoDmlWireCommand>;
+}
+//#endregion
+//#region src/driver-types.d.ts
+interface MongoDriver {
+  execute<Row>(wireCommand: AnyMongoDmlWireCommand): AsyncIterable<Row>;
+  run(wireCommand: AnyMongoDdlWireCommand): Promise<void>;
+  close(): Promise<void>;
+}
+interface MongoControlDriverInstance extends ControlDriverInstance<'mongo', 'mongo'>, MongoDriver {
+  readonly db: Db;
+}
+//#endregion
+export { MongoLoweredDraft as a, MongoDriver as i, MongoControlDriverInstance as n, MongoDdlPlan as r, MongoAdapter as t };
+//# sourceMappingURL=index-DAOkcTCK.d.mts.map

package/dist/index-DAOkcTCK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DAOkcTCK.d.mts","names":[],"sources":["../../../../2-mongo-family/6-transport/mongo-lowering/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;KAkBK;WACM;WACA;WACA,UAAU;;WAEV;WACA;WACA,WAAW,cAAc;;WAEzB;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;WAChD;;WAEA;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;WAChD;;WAEA;WACA;WACA,QAAQ;;WAER;WACA;WACA,QAAQ;;WAER;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;WAChD;WACA,MAAM;WACN;;WAEA;WACA;WACA,QAAQ;WACR,MAAM;;WAEN;WACA;WACA,UAAU,cAAc;;WAExB;WACA;WACA,UAAU;;WAEV;WACA;WACA,WAAW,cAAc;;WAEzB;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;;WAEhD;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;;WAEhD;WACA;WACA,QAAQ;;WAER;WACA;WACA,QAAQ;;WAER;WACA;WACA,QAAQ;WACR,QAAQ,0BAA0B,cAAc;WAChD;WACA,MAAM;WACN;;WAEA;WACA;WACA,QAAQ;WACR,MAAM;;WAEN;WACA;WACA,UAAU,cAAc;;;UAGzB;WACC,SAAS;;UAEV;EACR,MAAM,MAAM,cAAc,KAAK,mBAAmB,QAAQ;EAC1D,MAAM,MAAM,gBAAgB,KAAK,mBAAmB,QAAQ;EAC5D,MAAM,MAAM,iBAAiB,cAAc,KAAK,mBAAmB,QAAQ;;;;;;;;;;;EAW3E,gBAAgB,MAAM,iBAAiB;;;;;;;;;EASvC,cAAc,OAAO,mBAAmB,KAAK,mBAAmB,QAAQ;;;;UAIhE;EACR,QAAQ,KAAK,aAAa,yBAAyB,cAAc;EACjE,IAAI,aAAa,yBAAyB;EAC1C,SAAS;;UAED,mCAAmC,yCAAyC;WAC3E,IAAI"}