@prisma-next/mongo-orm 0.3.0-dev.134 → 0.3.0-dev.162

package/dist/index.mjs

@@ -1,77 +1,608 @@
-import { AggregateCommand, FindCommand } from "@prisma-next/mongo-core";
+import { AsyncIterableResult } from "@prisma-next/framework-components/runtime";
+import { AggregateCommand, DeleteManyCommand, FindOneAndDeleteCommand, FindOneAndUpdateCommand, InsertManyCommand, InsertOneCommand, MongoAndExpr, MongoFieldFilter, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoProjectStage, MongoSkipStage, MongoSortStage, MongoUnwindStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand, UpdateManyCommand, isMongoFilterExpr } from "@prisma-next/mongo-query-ast/execution";
+import { MongoParamRef } from "@prisma-next/mongo-value";
 
-//#region src/mongo-orm.ts
-const stubMeta = {
-	target: "mongo",
-	storageHash: "orm",
-	lane: "mongo-orm",
-	paramDescriptors: []
-};
-function resolveCollection(model, modelName) {
-	return model.storage.collection ?? modelName;
+//#region src/collection-state.ts
+function emptyCollectionState() {
+	return {
+		filters: [],
+		includes: [],
+		orderBy: void 0,
+		selectedFields: void 0,
+		limit: void 0,
+		offset: void 0
+	};
 }
-function buildLookupStages(contract, model, include) {
+
+//#endregion
+//#region src/compile.ts
+function compileIncludes(includes) {
 	const stages = [];
-	for (const [relName, shouldInclude] of Object.entries(include)) {
-		if (!shouldInclude) continue;
-		const relation = model.relations?.[relName];
-		if (!relation) continue;
-		const targetModel = contract.models[relation.to];
-		if (!targetModel || targetModel.owner) continue;
-		const ref = relation;
-		if (ref.on.localFields.length !== 1 || ref.on.targetFields.length !== 1) throw new Error(`Compound references are not yet supported: relation "${relName}" has ${ref.on.localFields.length} local field(s) and ${ref.on.targetFields.length} target field(s)`);
-		const targetCollection = resolveCollection(targetModel, ref.to);
-		stages.push({ $lookup: {
-			from: targetCollection,
-			localField: ref.on.localFields[0],
-			foreignField: ref.on.targetFields[0],
-			as: relName
-		} });
-		if (ref.cardinality === "N:1" || ref.cardinality === "1:1") stages.push({ $unwind: {
-			path: `$${relName}`,
-			preserveNullAndEmptyArrays: true
-		} });
+	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;
 }
-var MongoCollectionImpl = class {
+function compileMongoQuery(collection, state, storageHash) {
+	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",
+		paramDescriptors: []
+	};
+	return {
+		collection,
+		command: new AggregateCommand(collection, stages),
+		meta
+	};
+}
+
+//#endregion
+//#region src/field-accessor.ts
+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;
+}
+
+//#endregion
+//#region src/collection.ts
+function resolveCollectionName(model, modelName) {
+	return model.storage.collection ?? modelName;
+}
+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 = contract.models[modelName];
+		this.#collectionName = resolveCollectionName(model, modelName);
+		this.#state = emptyCollectionState();
 	}
-	findMany(options) {
+	variant(variantName) {
 		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
+		if (!model?.discriminator || !model.variants) return this;
+		const variantEntry = model.variants[variantName];
+		if (!variantEntry) return 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(filter);
+		return this.#clone({ filters: [...this.#state.filters, ...compiled] });
+	}
+	select(...fields) {
+		return this.#clone({ selectedFields: [...this.#state.selectedFields ?? [], ...fields] });
+	}
+	include(relationName) {
+		const relation = this.#contract.models[this.#modelName].relations?.[relationName];
+		if (!relation) throw new Error(`Unknown relation "${relationName}" on model "${this.#modelName}"`);
+		if (!("on" in relation)) throw new Error(`Relation "${relationName}" is an embed relation — only reference relations can be included`);
+		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 new Error(`Compound references are not yet supported: relation "${relationName}"`);
+		const targetModel = this.#contract.models[ref.to];
+		if (!targetModel) throw new Error(`Target model "${ref.to}" not found for relation "${relationName}"`);
+		const includeExpr = {
+			relationName,
+			from: resolveCollectionName(targetModel, ref.to),
+			localField,
+			foreignField,
+			cardinality: ref.cardinality
 		};
+		return 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(data));
+		const document = this.#toDocument(normalized);
+		const command = new InsertOneCommand(this.#collectionName, document);
+		return {
+			_id: (await this.#drainPlan(command))[0].insertedId,
+			...normalized
+		};
+	}
+	createAll(data) {
+		this.#rejectIncludes("createAll");
+		const self = this;
+		async function* gen() {
+			const normalizedRows = data.map((d) => self.#injectDiscriminator(self.#stripUndefined(d)));
+			const documents = normalizedRows.map((d) => self.#toDocument(d));
+			const command = new InsertManyCommand(self.#collectionName, documents);
+			const insertedIds = (await self.#drainPlan(command))[0].insertedIds;
+			for (let i = 0; i < normalizedRows.length; i++) yield {
+				_id: insertedIds[i],
+				...normalizedRows[i]
+			};
+		}
+		return new AsyncIterableResult(gen());
+	}
+	async createCount(data) {
+		this.#rejectIncludes("createCount");
+		const documents = data.map((d) => this.#toDocument(this.#injectDiscriminator(d)));
+		const command = new InsertManyCommand(this.#collectionName, documents);
+		return (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);
+		return (await this.#drainPlan(command))[0] ?? null;
+	}
+	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 updateCount(dataOrCallback) {
+		this.#requireFilters("updateCount");
+		this.#rejectWindowing("updateCount");
+		this.#rejectIncludes("updateCount");
+		const filter = this.#mergeFilters();
+		const updateDoc = this.#resolveUpdateDoc(dataOrCallback);
+		const command = new UpdateManyCommand(this.#collectionName, filter, updateDoc);
+		return (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);
+		return (await this.#drainPlan(command))[0] ?? null;
+	}
+	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 deleteCount() {
+		this.#requireFilters("deleteCount");
+		this.#rejectWindowing("deleteCount");
+		this.#rejectIncludes("deleteCount");
+		const filter = this.#mergeFilters();
+		const command = new DeleteManyCommand(this.#collectionName, filter);
+		return (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(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 new Error("Mutation payloads cannot modify `_id`");
+			const dotPathOp = ops.find((op) => op.field.includes("."));
+			if (dotPathOp) throw new Error(`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.`);
+			updateDoc = compileFieldOperations(ops, (field, value, operator) => this.#wrapFieldOpValue(field, value, operator));
+		} else {
+			const setFields = this.#toSetFields(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 (await this.#drainPlan(command))[0];
+	}
+	async #readMatchingIds() {
+		const idQuery = this.#clone({
+			includes: [],
+			selectedFields: ["_id"],
+			orderBy: void 0,
+			limit: void 0,
+			offset: void 0
+		});
+		const ids = [];
+		for await (const row of idQuery.#execute()) ids.push(row["_id"]);
+		return ids;
+	}
+	#execute() {
+		const plan = this.#compile();
 		return this.#executor.execute(plan);
 	}
+	#compile() {
+		return compileMongoQuery(this.#collectionName, this.#state, this.#contract.storage.storageHash);
+	}
+	#wrapCommand(command) {
+		return {
+			collection: this.#collectionName,
+			command,
+			meta: this.#planMeta()
+		};
+	}
+	async #drainPlan(command) {
+		const plan = this.#wrapCommand(command);
+		const result = this.#executor.execute(plan);
+		const rows = [];
+		for await (const row of result) rows.push(row);
+		return rows;
+	}
+	#modelFields() {
+		return this.#contract.models[this.#modelName]?.fields ?? {};
+	}
+	#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 = this.#contract.valueObjects?.[voName];
+			if (!voDef || value === null) return new MongoParamRef(value);
+			if (field.many && Array.isArray(value)) return value.map((item) => this.#wrapValueObject(item, voDef));
+			return this.#wrapValueObject(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 new Error("Mutation payloads cannot modify `_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 new Error("Mutation payloads cannot modify `_id`");
+			if (ops.length === 0) return { $set: {} };
+			return compileFieldOperations(ops, (field, value, operator) => this.#wrapFieldOpValue(field, value, operator));
+		}
+		return this.#toUpdateDocument(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 (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+				const voName = contractField.type.name;
+				const voDef = this.#contract.valueObjects?.[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 || currentField.type.kind !== "valueObject") return value;
+			const voName = currentField.type.name;
+			const voDef = this.#contract.valueObjects?.[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 (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+				const voName = currentField.type.name;
+				const voDef = this.#contract.valueObjects?.[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 new Error(`${methodName}() requires a .where() filter. Call .where() before .${methodName}()`);
+	}
+	#rejectWindowing(methodName) {
+		if (this.#state.orderBy !== void 0 || this.#state.limit !== void 0 || this.#state.offset !== void 0) throw new Error(`${methodName}() does not support orderBy/skip/take. Remove windowing before calling .${methodName}()`);
+	}
+	#rejectIncludes(methodName) {
+		if (this.#state.includes.length > 0) throw new Error(`${methodName}() does not support .include(). Remove includes before calling .${methodName}()`);
+	}
+	#planMeta() {
+		return {
+			target: "mongo",
+			storageHash: this.#contract.storage.storageHash,
+			lane: "mongo-orm",
+			paramDescriptors: []
+		};
+	}
+	#injectDiscriminator(data) {
+		if (!this.#variantName) return data;
+		const model = this.#contract.models[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);
+}
+
+//#endregion
+//#region src/mongo-orm.ts
 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);
+	for (const [rootName, modelName] of Object.entries(contract.roots)) client[rootName] = createMongoCollection(contract, modelName, executor);
 	return client;
 }
 
 //#endregion
-export { mongoOrm };
+//#region src/raw-collection.ts
+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));
+		}
+	};
+}
+
+//#endregion
+//#region src/mongo-raw.ts
+function mongoRaw(options) {
+	const { contract } = options;
+	return { collection(rootName) {
+		const modelName = contract.roots[rootName];
+		if (!Object.hasOwn(contract.models, modelName)) throw new Error(`Unknown model "${modelName}" for root "${rootName}"`);
+		return createRawMongoCollection(contract.models[modelName].storage.collection ?? modelName, {
+			target: "mongo",
+			storageHash: contract.storage.storageHash,
+			lane: "mongo-raw",
+			paramDescriptors: []
+		});
+	} };
+}
+
+//#endregion
+export { compileMongoQuery, createFieldAccessor, createMongoCollection, mongoOrm, mongoRaw };
 //# sourceMappingURL=index.mjs.map