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

package/dist/orm.mjs

@@ -0,0 +1,664 @@
+import { t as MongoParamRef } from "./dist-C7Ykq48Q.mjs";
+import { a as MongoFieldFilter, c as isMongoFilterExpr, t as MongoAndExpr } from "./filter-expressions-Uo8ZdzwB-53qnqceS.mjs";
+import { $ as RawInsertOneCommand, A as MongoLookupStage, G as MongoUnwindStage, J as RawDeleteManyCommand, P as MongoProjectStage, Q as RawInsertManyCommand, U as MongoSortStage, V as MongoSkipStage, X as RawFindOneAndDeleteCommand, Y as RawDeleteOneCommand, Z as RawFindOneAndUpdateCommand, a as FindOneAndUpdateCommand, at as freezeMongoResultShape, et as RawUpdateManyCommand, i as FindOneAndDeleteCommand, j as MongoMatchStage, k as MongoLimitStage, n as DeleteManyCommand, nt as UpdateManyCommand, o as InsertManyCommand, q as RawAggregateCommand, s as InsertOneCommand, t as AggregateCommand, tt as RawUpdateOneCommand } from "./execution-D5XyZ5XS.mjs";
+import { a as contractFieldToMongoFieldShape, o as contractModelToMongoResultShape } from "./dist-Dyp05u64.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { domainModelsAtDefaultNamespace, domainValueObjectsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-mongo-family/5-query-builders/orm/dist/index.mjs
+function emptyCollectionState() {
+	return {
+		filters: [],
+		includes: [],
+		orderBy: void 0,
+		selectedFields: void 0,
+		limit: void 0,
+		offset: void 0
+	};
+}
+function compileIncludes(includes) {
+	const stages = [];
+	for (const inc of includes) {
+		stages.push(new MongoLookupStage({
+			from: inc.from,
+			localField: inc.localField,
+			foreignField: inc.foreignField,
+			as: inc.relationName
+		}));
+		if (inc.cardinality === "N:1" || inc.cardinality === "1:1") stages.push(new MongoUnwindStage(`$${inc.relationName}`, true));
+	}
+	return stages;
+}
+function compileMongoQuery(collection, state, storageHash, model) {
+	const stages = [];
+	const singleFilter = state.filters.length === 1 ? state.filters[0] : void 0;
+	if (singleFilter) stages.push(new MongoMatchStage(singleFilter));
+	else if (state.filters.length > 1) stages.push(new MongoMatchStage(MongoAndExpr.of([...state.filters])));
+	if (state.includes.length > 0) stages.push(...compileIncludes(state.includes));
+	if (state.orderBy) stages.push(new MongoSortStage(state.orderBy));
+	if (state.offset !== void 0) stages.push(new MongoSkipStage(state.offset));
+	if (state.limit !== void 0) stages.push(new MongoLimitStage(state.limit));
+	if (state.selectedFields && state.selectedFields.length > 0) {
+		const projection = {};
+		for (const field of state.selectedFields) projection[field] = 1;
+		if (!Object.hasOwn(projection, "_id")) projection["_id"] = 0;
+		stages.push(new MongoProjectStage(projection));
+	}
+	const meta = {
+		target: "mongo",
+		storageHash,
+		lane: "mongo-orm"
+	};
+	const command = new AggregateCommand(collection, stages);
+	const selection = state.selectedFields !== void 0 && state.selectedFields.length > 0 ? state.selectedFields : void 0;
+	const includeRelationNames = state.includes.length > 0 ? state.includes.map((inc) => inc.relationName) : void 0;
+	return {
+		collection,
+		command,
+		meta,
+		resultShape: contractModelToMongoResultShape(model, {
+			...ifDefined("selection", selection),
+			...ifDefined("includeRelationNames", includeRelationNames)
+		})
+	};
+}
+function createFieldExpression(fieldPath) {
+	return {
+		set(value) {
+			return {
+				operator: "$set",
+				field: fieldPath,
+				value: new MongoParamRef(value)
+			};
+		},
+		unset() {
+			return {
+				operator: "$unset",
+				field: fieldPath,
+				value: new MongoParamRef("")
+			};
+		},
+		inc(value) {
+			return {
+				operator: "$inc",
+				field: fieldPath,
+				value: new MongoParamRef(value)
+			};
+		},
+		mul(value) {
+			return {
+				operator: "$mul",
+				field: fieldPath,
+				value: new MongoParamRef(value)
+			};
+		},
+		push(value) {
+			return {
+				operator: "$push",
+				field: fieldPath,
+				value: new MongoParamRef(value)
+			};
+		},
+		pull(match) {
+			return {
+				operator: "$pull",
+				field: fieldPath,
+				value: new MongoParamRef(match)
+			};
+		},
+		addToSet(value) {
+			return {
+				operator: "$addToSet",
+				field: fieldPath,
+				value: new MongoParamRef(value)
+			};
+		},
+		pop(end) {
+			return {
+				operator: "$pop",
+				field: fieldPath,
+				value: new MongoParamRef(end)
+			};
+		}
+	};
+}
+function createFieldAccessor() {
+	return new Proxy((() => {}), {
+		get(_target, prop) {
+			return createFieldExpression(prop);
+		},
+		apply(_target, _thisArg, args) {
+			return createFieldExpression(args[0]);
+		}
+	});
+}
+function compileFieldOperations(ops, wrapValue) {
+	const grouped = {};
+	for (const op of ops) {
+		let group = grouped[op.operator];
+		if (!group) {
+			group = {};
+			grouped[op.operator] = group;
+		}
+		group[op.field] = wrapValue(op.field, op.value, op.operator);
+	}
+	return grouped;
+}
+function ormError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function resolveCollectionName(model, modelName) {
+	return model.storage.collection ?? modelName;
+}
+function isUnknownRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MongoCollectionImpl = class MongoCollectionImpl {
+	#contract;
+	#modelName;
+	#executor;
+	#collectionName;
+	#state;
+	#variantName;
+	constructor(contract, modelName, executor) {
+		this.#contract = contract;
+		this.#modelName = modelName;
+		this.#executor = executor;
+		const model = blindCast(domainModelsAtDefaultNamespace(contract.domain)[modelName]);
+		this.#collectionName = resolveCollectionName(model, modelName);
+		this.#state = emptyCollectionState();
+	}
+	variant(variantName) {
+		const model = blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName]);
+		if (!model?.discriminator || !model.variants) return blindCast(this);
+		const variantEntry = model.variants[variantName];
+		if (!variantEntry) return blindCast(this);
+		const filter = MongoFieldFilter.eq(model.discriminator.field, new MongoParamRef(variantEntry.value));
+		return this.#cloneWithVariant({ filters: [...this.#state.filters, filter] }, variantName);
+	}
+	where(filter) {
+		if (isMongoFilterExpr(filter)) return this.#clone({ filters: [...this.#state.filters, filter] });
+		const compiled = this.#compileWhereObject(blindCast(filter));
+		return this.#clone({ filters: [...this.#state.filters, ...compiled] });
+	}
+	select(...fields) {
+		return this.#clone({ selectedFields: [...this.#state.selectedFields ?? [], ...fields] });
+	}
+	include(relationName) {
+		const relation = blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName]).relations?.[relationName];
+		if (!relation) throw ormError("ORM.RELATION_UNKNOWN", `Unknown relation "${relationName}" on model "${this.#modelName}"`, { meta: {
+			model: this.#modelName,
+			relation: relationName
+		} });
+		if (!("on" in relation)) throw ormError("ORM.INCLUDE_UNSUPPORTED", `Relation "${relationName}" is an embed relation — only reference relations can be included`, { meta: {
+			model: this.#modelName,
+			relation: relationName
+		} });
+		const ref = relation;
+		const localField = ref.on.localFields[0];
+		const foreignField = ref.on.targetFields[0];
+		if (!localField || !foreignField || ref.on.localFields.length !== 1 || ref.on.targetFields.length !== 1) throw ormError("ORM.INCLUDE_UNSUPPORTED", `Compound references are not yet supported: relation "${relationName}"`, { meta: {
+			model: this.#modelName,
+			relation: relationName
+		} });
+		const targetModelName = ref.to.model;
+		const targetModel = castAs(domainModelsAtDefaultNamespace(this.#contract.domain)[targetModelName]);
+		if (!targetModel) throw new InternalError(`Target model "${targetModelName}" not found for relation "${relationName}"`);
+		const includeExpr = {
+			relationName,
+			from: resolveCollectionName(targetModel, targetModelName),
+			localField,
+			foreignField,
+			cardinality: ref.cardinality
+		};
+		return blindCast(this.#clone({ includes: [...this.#state.includes, includeExpr] }));
+	}
+	orderBy(spec) {
+		const merged = {
+			...this.#state.orderBy,
+			...spec
+		};
+		return this.#clone({ orderBy: merged });
+	}
+	take(n) {
+		return this.#clone({ limit: n });
+	}
+	skip(n) {
+		return this.#clone({ offset: n });
+	}
+	all() {
+		return this.#execute();
+	}
+	async first() {
+		const result = this.#clone({ limit: 1 }).#execute();
+		for await (const row of result) return row;
+		return null;
+	}
+	async create(data) {
+		this.#rejectIncludes("create");
+		const normalized = this.#injectDiscriminator(this.#stripUndefined(blindCast(data)));
+		const document = this.#toDocument(normalized);
+		const command = new InsertOneCommand(this.#collectionName, document);
+		const insertedId = blindCast((await this.#drainPlan(command, this.#insertOneResultShape()))[0]).insertedId;
+		return blindCast({
+			_id: insertedId,
+			...normalized
+		});
+	}
+	createAll(data) {
+		this.#rejectIncludes("createAll");
+		const self = this;
+		async function* gen() {
+			const normalizedRows = data.map((d) => self.#injectDiscriminator(self.#stripUndefined(blindCast(d))));
+			const documents = normalizedRows.map((d) => self.#toDocument(d));
+			const command = new InsertManyCommand(self.#collectionName, documents);
+			const insertedIds = blindCast((await self.#drainPlan(command, self.#insertManyResultShape()))[0]).insertedIds;
+			for (let i = 0; i < normalizedRows.length; i++) yield blindCast({
+				_id: insertedIds[i],
+				...normalizedRows[i]
+			});
+		}
+		return new AsyncIterableResult(gen());
+	}
+	async createAndCount(data) {
+		this.#rejectIncludes("createAndCount");
+		const documents = data.map((d) => this.#toDocument(this.#injectDiscriminator(blindCast(d))));
+		const command = new InsertManyCommand(this.#collectionName, documents);
+		return blindCast((await this.#drainPlan(command))[0]).insertedCount;
+	}
+	async update(dataOrCallback) {
+		this.#requireFilters("update");
+		this.#rejectWindowing("update");
+		this.#rejectIncludes("update");
+		const filter = this.#mergeFilters();
+		const updateDoc = this.#resolveUpdateDoc(dataOrCallback);
+		const command = new FindOneAndUpdateCommand(this.#collectionName, filter, updateDoc, false);
+		const result = (await this.#drainPlan(command, this.#modelResultShape()))[0];
+		return result === void 0 ? null : blindCast(result);
+	}
+	updateAll(dataOrCallback) {
+		this.#requireFilters("updateAll");
+		this.#rejectWindowing("updateAll");
+		const self = this;
+		async function* gen() {
+			const ids = await self.#readMatchingIds();
+			if (ids.length === 0) return;
+			const filter = self.#mergeFilters();
+			const updateDoc = self.#resolveUpdateDoc(dataOrCallback);
+			const command = new UpdateManyCommand(self.#collectionName, filter, updateDoc);
+			await self.#drainPlan(command);
+			const idFilter = MongoFieldFilter.in("_id", ids.map((id) => new MongoParamRef(id)));
+			yield* self.#clone({ filters: [idFilter] }).#execute();
+		}
+		return new AsyncIterableResult(gen());
+	}
+	async updateAndCount(dataOrCallback) {
+		this.#requireFilters("updateAndCount");
+		this.#rejectWindowing("updateAndCount");
+		this.#rejectIncludes("updateAndCount");
+		const filter = this.#mergeFilters();
+		const updateDoc = this.#resolveUpdateDoc(dataOrCallback);
+		const command = new UpdateManyCommand(this.#collectionName, filter, updateDoc);
+		return blindCast((await this.#drainPlan(command))[0]).modifiedCount;
+	}
+	async delete() {
+		this.#requireFilters("delete");
+		this.#rejectWindowing("delete");
+		this.#rejectIncludes("delete");
+		const filter = this.#mergeFilters();
+		const command = new FindOneAndDeleteCommand(this.#collectionName, filter);
+		const result = (await this.#drainPlan(command, this.#modelResultShape()))[0];
+		return result === void 0 ? null : blindCast(result);
+	}
+	deleteAll() {
+		this.#requireFilters("deleteAll");
+		this.#rejectWindowing("deleteAll");
+		const self = this;
+		async function* gen() {
+			const docs = [];
+			for await (const row of self.#execute()) docs.push(row);
+			const filter = self.#mergeFilters();
+			const command = new DeleteManyCommand(self.#collectionName, filter);
+			await self.#drainPlan(command);
+			yield* docs;
+		}
+		return new AsyncIterableResult(gen());
+	}
+	async deleteAndCount() {
+		this.#requireFilters("deleteAndCount");
+		this.#rejectWindowing("deleteAndCount");
+		this.#rejectIncludes("deleteAndCount");
+		const filter = this.#mergeFilters();
+		const command = new DeleteManyCommand(this.#collectionName, filter);
+		return blindCast((await this.#drainPlan(command))[0]).deletedCount;
+	}
+	async upsert(input) {
+		this.#requireFilters("upsert");
+		this.#rejectWindowing("upsert");
+		this.#rejectIncludes("upsert");
+		const filter = this.#mergeFilters();
+		const allCreateFields = this.#toDocument(this.#injectDiscriminator(blindCast(input.create)));
+		let updateDoc;
+		if (typeof input.update === "function") {
+			const accessor = createFieldAccessor();
+			const ops = input.update(accessor);
+			if (ops.find((op) => op.field === "_id")) throw ormError("ORM.FIELD_IMMUTABLE", "Mutation payloads cannot modify `_id`", { meta: { field: "_id" } });
+			const dotPathOp = ops.find((op) => op.field.includes("."));
+			if (dotPathOp) throw ormError("ORM.OPERATION_UNSUPPORTED", `upsert() does not support dot-path field operations (found "${dotPathOp.field}"). Dot-path updates conflict with \$setOnInsert on the insert path, producing incomplete documents. Use top-level field operations instead.`, { meta: {
+				method: "upsert",
+				field: dotPathOp.field
+			} });
+			updateDoc = compileFieldOperations(ops, (field, value, operator) => this.#wrapFieldOpValue(field, value, operator));
+		} else {
+			const setFields = this.#toSetFields(blindCast(input.update));
+			updateDoc = {};
+			if (Object.keys(setFields).length > 0) updateDoc["$set"] = setFields;
+		}
+		const updatedFields = /* @__PURE__ */ new Set();
+		for (const operatorGroup of Object.values(updateDoc)) for (const fieldPath of Object.keys(operatorGroup)) updatedFields.add(fieldPath.split(".")[0] ?? fieldPath);
+		const insertOnlyFields = {};
+		for (const [key, value] of Object.entries(allCreateFields)) if (!updatedFields.has(key)) insertOnlyFields[key] = value;
+		if (Object.keys(insertOnlyFields).length > 0) updateDoc["$setOnInsert"] = insertOnlyFields;
+		const command = new FindOneAndUpdateCommand(this.#collectionName, filter, updateDoc, true);
+		return blindCast((await this.#drainPlan(command, this.#modelResultShape()))[0]);
+	}
+	async #readMatchingIds() {
+		const idQuery = this.#clone({
+			includes: [],
+			selectedFields: ["_id"],
+			orderBy: void 0,
+			limit: void 0,
+			offset: void 0
+		});
+		const ids = [];
+		const { resultShape: _rs, ...planWithoutShape } = idQuery.#compile();
+		for await (const row of this.#executor.execute(planWithoutShape)) {
+			const storageRow = blindCast(row);
+			ids.push(storageRow["_id"]);
+		}
+		return ids;
+	}
+	#execute() {
+		const plan = this.#compile();
+		return this.#executor.execute(plan);
+	}
+	#compile() {
+		const model = blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName]);
+		if (!model) throw ormError("ORM.MODEL_UNKNOWN", `Unknown model: "${this.#modelName}".`, { meta: { model: this.#modelName } });
+		return compileMongoQuery(this.#collectionName, this.#state, this.#contract.storage.storageHash, model);
+	}
+	#wrapCommand(command, resultShape) {
+		return {
+			collection: this.#collectionName,
+			command,
+			meta: this.#planMeta(),
+			...ifDefined("resultShape", resultShape)
+		};
+	}
+	async #drainPlan(command, resultShape) {
+		const plan = this.#wrapCommand(command, resultShape);
+		const result = this.#executor.execute(plan);
+		const rows = [];
+		for await (const row of result) rows.push(row);
+		return rows;
+	}
+	#modelFields() {
+		return blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName])?.fields ?? {};
+	}
+	#idFieldShape() {
+		const idField = this.#modelFields()["_id"];
+		return idField ? contractFieldToMongoFieldShape(idField) : Object.freeze({ kind: "unknown" });
+	}
+	#insertOneResultShape() {
+		return freezeMongoResultShape({
+			kind: "document",
+			fields: { insertedId: this.#idFieldShape() }
+		});
+	}
+	#insertManyResultShape() {
+		return freezeMongoResultShape({
+			kind: "document",
+			fields: { insertedIds: {
+				kind: "array",
+				nullable: false,
+				element: this.#idFieldShape()
+			} }
+		});
+	}
+	#modelResultShape() {
+		const model = blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName]);
+		if (!model) return Object.freeze({ kind: "unknown" });
+		return contractModelToMongoResultShape(model);
+	}
+	#compileWhereObject(data) {
+		const fields = this.#modelFields();
+		const filters = [];
+		for (const [key, value] of Object.entries(data)) {
+			if (value === void 0) continue;
+			const wrapped = this.#wrapFieldValue(value, fields[key]);
+			filters.push(MongoFieldFilter.eq(key, wrapped));
+		}
+		return filters;
+	}
+	#wrapFieldValue(value, field) {
+		if (field === void 0) return new MongoParamRef(value);
+		if (field.type.kind === "scalar") return new MongoParamRef(value, { codecId: field.type.codecId });
+		if (field.type.kind === "valueObject") {
+			const voName = field.type.name;
+			const voDef = domainValueObjectsAtDefaultNamespace(this.#contract.domain)?.[voName];
+			if (!voDef || value === null) return new MongoParamRef(value);
+			if (field.many && Array.isArray(value)) return value.map((item) => this.#wrapValueObject(blindCast(item), voDef));
+			return this.#wrapValueObject(blindCast(value), voDef);
+		}
+		return new MongoParamRef(value);
+	}
+	#wrapValueObject(data, voDef) {
+		const doc = {};
+		for (const [key, value] of Object.entries(data)) {
+			if (value === void 0) continue;
+			const fieldDef = voDef.fields[key];
+			doc[key] = this.#wrapFieldValue(value, fieldDef);
+		}
+		return doc;
+	}
+	#toDocument(data) {
+		const fields = this.#modelFields();
+		const doc = {};
+		for (const [key, value] of Object.entries(data)) if (value !== void 0) doc[key] = this.#wrapFieldValue(value, fields[key]);
+		return doc;
+	}
+	#toSetFields(data) {
+		const fields = this.#modelFields();
+		const result = {};
+		for (const [key, value] of Object.entries(data)) {
+			if (key === "_id" && value !== void 0) throw ormError("ORM.FIELD_IMMUTABLE", "Mutation payloads cannot modify `_id`", { meta: { field: "_id" } });
+			if (value !== void 0) result[key] = this.#wrapFieldValue(value, fields[key]);
+		}
+		return result;
+	}
+	#stripUndefined(data) {
+		const result = {};
+		for (const [key, value] of Object.entries(data)) if (value !== void 0) result[key] = value;
+		return result;
+	}
+	#toUpdateDocument(data) {
+		return { $set: this.#toSetFields(data) };
+	}
+	#resolveUpdateDoc(dataOrCallback) {
+		if (typeof dataOrCallback === "function") {
+			const ops = dataOrCallback(createFieldAccessor());
+			if (ops.find((op) => op.field === "_id")) throw ormError("ORM.FIELD_IMMUTABLE", "Mutation payloads cannot modify `_id`", { meta: { field: "_id" } });
+			if (ops.length === 0) return { $set: {} };
+			return compileFieldOperations(ops, (field, value, operator) => this.#wrapFieldOpValue(field, value, operator));
+		}
+		return this.#toUpdateDocument(blindCast(dataOrCallback));
+	}
+	#wrapFieldOpValue(field, value, operator) {
+		if (operator === "$unset") return value;
+		const topLevelField = field.split(".")[0] ?? field;
+		const contractField = this.#modelFields()[topLevelField];
+		if (!contractField) return value;
+		if (field.includes(".")) return this.#wrapDotPathValue(field, value);
+		if (value instanceof MongoParamRef && contractField.type.kind === "scalar") return new MongoParamRef(value.value, { codecId: contractField.type.codecId });
+		if (contractField.type.kind === "valueObject" && value instanceof MongoParamRef) {
+			const raw = value.value;
+			if (isUnknownRecord(raw)) {
+				const voName = contractField.type.name;
+				const voDef = domainValueObjectsAtDefaultNamespace(this.#contract.domain)?.[voName];
+				if (voDef) return this.#wrapValueObject(raw, voDef);
+			}
+		}
+		return value;
+	}
+	#wrapDotPathValue(dotPath, value) {
+		const parts = dotPath.split(".");
+		const fields = this.#modelFields();
+		let currentField = parts[0] ? fields[parts[0]] : void 0;
+		for (let i = 1; i < parts.length; i++) {
+			if (currentField?.type.kind !== "valueObject") return value;
+			const voName = currentField.type.name;
+			const voDef = domainValueObjectsAtDefaultNamespace(this.#contract.domain)?.[voName];
+			if (!voDef) return value;
+			const partKey = parts[i];
+			currentField = partKey ? voDef.fields[partKey] : void 0;
+		}
+		if (currentField?.type.kind === "scalar" && value instanceof MongoParamRef) return new MongoParamRef(value.value, { codecId: currentField.type.codecId });
+		if (currentField?.type.kind === "valueObject" && value instanceof MongoParamRef) {
+			const raw = value.value;
+			if (isUnknownRecord(raw)) {
+				const voName = currentField.type.name;
+				const voDef = domainValueObjectsAtDefaultNamespace(this.#contract.domain)?.[voName];
+				if (voDef) return this.#wrapValueObject(raw, voDef);
+			}
+		}
+		return value;
+	}
+	#mergeFilters() {
+		const [single] = this.#state.filters;
+		if (this.#state.filters.length === 1 && single) return single;
+		return MongoAndExpr.of([...this.#state.filters]);
+	}
+	#requireFilters(methodName) {
+		if (this.#state.filters.length === 0) throw ormError("ORM.WHERE_MISSING", `${methodName}() requires a .where() filter. Call .where() before .${methodName}()`, { meta: { method: methodName } });
+	}
+	#rejectWindowing(methodName) {
+		if (this.#state.orderBy !== void 0 || this.#state.limit !== void 0 || this.#state.offset !== void 0) throw ormError("ORM.OPERATION_UNSUPPORTED", `${methodName}() does not support orderBy/skip/take. Remove windowing before calling .${methodName}()`, { meta: {
+			method: methodName,
+			reason: "windowing"
+		} });
+	}
+	#rejectIncludes(methodName) {
+		if (this.#state.includes.length > 0) throw ormError("ORM.OPERATION_UNSUPPORTED", `${methodName}() does not support .include(). Remove includes before calling .${methodName}()`, { meta: {
+			method: methodName,
+			reason: "includes"
+		} });
+	}
+	#planMeta() {
+		return {
+			target: "mongo",
+			storageHash: this.#contract.storage.storageHash,
+			lane: "mongo-orm"
+		};
+	}
+	#injectDiscriminator(data) {
+		if (!this.#variantName) return data;
+		const model = blindCast(domainModelsAtDefaultNamespace(this.#contract.domain)[this.#modelName]);
+		if (!model?.discriminator || !model.variants) return data;
+		const variantEntry = model.variants[this.#variantName];
+		if (!variantEntry) return data;
+		return {
+			...data,
+			[model.discriminator.field]: variantEntry.value
+		};
+	}
+	#clone(overrides) {
+		const instance = new MongoCollectionImpl(this.#contract, this.#modelName, this.#executor);
+		instance.#state = {
+			...this.#state,
+			...overrides
+		};
+		instance.#collectionName = this.#collectionName;
+		instance.#variantName = this.#variantName;
+		return instance;
+	}
+	#cloneWithVariant(overrides, variantName) {
+		const instance = new MongoCollectionImpl(this.#contract, this.#modelName, this.#executor);
+		instance.#state = {
+			...this.#state,
+			...overrides
+		};
+		instance.#collectionName = this.#collectionName;
+		instance.#variantName = variantName;
+		return instance;
+	}
+};
+function createMongoCollection(contract, modelName, executor) {
+	return new MongoCollectionImpl(contract, modelName, executor);
+}
+function mongoOrm(options) {
+	const { contract, executor } = options;
+	const client = {};
+	for (const [rootName, rootRef] of Object.entries(contract.roots)) client[rootName] = createMongoCollection(contract, blindCast(rootRef.model), executor);
+	return client;
+}
+function createRawMongoCollection(collectionName, meta) {
+	function buildable(command) {
+		return { build: () => ({
+			collection: collectionName,
+			command,
+			meta
+		}) };
+	}
+	return {
+		aggregate(pipeline) {
+			return buildable(new RawAggregateCommand(collectionName, pipeline));
+		},
+		insertOne(document) {
+			return buildable(new RawInsertOneCommand(collectionName, document));
+		},
+		insertMany(documents) {
+			return buildable(new RawInsertManyCommand(collectionName, documents));
+		},
+		updateOne(filter, update) {
+			return buildable(new RawUpdateOneCommand(collectionName, filter, update));
+		},
+		updateMany(filter, update) {
+			return buildable(new RawUpdateManyCommand(collectionName, filter, update));
+		},
+		deleteOne(filter) {
+			return buildable(new RawDeleteOneCommand(collectionName, filter));
+		},
+		deleteMany(filter) {
+			return buildable(new RawDeleteManyCommand(collectionName, filter));
+		},
+		findOneAndUpdate(filter, update, options) {
+			return buildable(new RawFindOneAndUpdateCommand(collectionName, filter, update, options?.upsert ?? false));
+		},
+		findOneAndDelete(filter) {
+			return buildable(new RawFindOneAndDeleteCommand(collectionName, filter));
+		}
+	};
+}
+function mongoRaw(options) {
+	const { contract } = options;
+	return { collection(rootName) {
+		const modelName = contract.roots[rootName]?.model;
+		const models = domainModelsAtDefaultNamespace(contract.domain);
+		if (!modelName || !Object.hasOwn(models, modelName)) throw ormError("ORM.MODEL_UNKNOWN", `Unknown model "${modelName ?? ""}" for root "${rootName}"`, { meta: {
+			model: modelName ?? "",
+			root: rootName
+		} });
+		return createRawMongoCollection(models[modelName].storage.collection ?? modelName, {
+			target: "mongo",
+			storageHash: contract.storage.storageHash,
+			lane: "mongo-raw"
+		});
+	} };
+}
+//#endregion
+export { compileMongoQuery, createFieldAccessor, createMongoCollection, mongoOrm, mongoRaw };
+
+//# sourceMappingURL=orm.mjs.map