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

package/dist/execution-D5XyZ5XS.mjs

@@ -0,0 +1,1269 @@
+import { l as ormError, n as MongoAstNode } from "./filter-expressions-Uo8ZdzwB-53qnqceS.mjs";
+//#region ../../../2-mongo-family/4-query/query-ast/dist/exports/execution.mjs
+function isExprArray(args) {
+	return Array.isArray(args);
+}
+function isRecordArgs(args) {
+	return !Array.isArray(args) && typeof args === "object" && !("accept" in args);
+}
+function freezeRecordArgs(record) {
+	const frozen = {};
+	for (const [key, val] of Object.entries(record)) frozen[key] = Array.isArray(val) ? Object.freeze([...val]) : val;
+	return Object.freeze(frozen);
+}
+function rewriteRecordArgs(record, rewriter) {
+	const result = {};
+	for (const [key, val] of Object.entries(record)) if (Array.isArray(val)) result[key] = val.map((v) => v.rewrite(rewriter));
+	else result[key] = val.rewrite(rewriter);
+	return result;
+}
+var MongoAggExprNode = class extends MongoAstNode {};
+var MongoAggFieldRef = class MongoAggFieldRef extends MongoAggExprNode {
+	kind = "fieldRef";
+	path;
+	constructor(path) {
+		super();
+		if (!path) throw ormError("ORM.ARGUMENT_INVALID", "Field path must not be empty");
+		this.path = path;
+		this.freeze();
+	}
+	static of(path) {
+		return new MongoAggFieldRef(path);
+	}
+	accept(visitor) {
+		return visitor.fieldRef(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.fieldRef ? rewriter.fieldRef(this) : this;
+	}
+};
+var MongoAggLiteral = class MongoAggLiteral extends MongoAggExprNode {
+	kind = "literal";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+		this.freeze();
+	}
+	static of(value) {
+		return new MongoAggLiteral(value);
+	}
+	accept(visitor) {
+		return visitor.literal(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.literal ? rewriter.literal(this) : this;
+	}
+};
+var MongoAggOperator = class MongoAggOperator extends MongoAggExprNode {
+	kind = "operator";
+	op;
+	args;
+	constructor(op, args) {
+		super();
+		this.op = op;
+		if (Array.isArray(args)) this.args = Object.freeze([...args]);
+		else if (isRecordArgs(args)) this.args = freezeRecordArgs(args);
+		else this.args = args;
+		this.freeze();
+	}
+	static of(op, args) {
+		return new MongoAggOperator(op, args);
+	}
+	static add(...args) {
+		return new MongoAggOperator("$add", args);
+	}
+	static subtract(left, right) {
+		return new MongoAggOperator("$subtract", [left, right]);
+	}
+	static multiply(...args) {
+		return new MongoAggOperator("$multiply", args);
+	}
+	static divide(dividend, divisor) {
+		return new MongoAggOperator("$divide", [dividend, divisor]);
+	}
+	static concat(...args) {
+		return new MongoAggOperator("$concat", args);
+	}
+	static toLower(expr) {
+		return new MongoAggOperator("$toLower", expr);
+	}
+	static toUpper(expr) {
+		return new MongoAggOperator("$toUpper", expr);
+	}
+	static size(expr) {
+		return new MongoAggOperator("$size", expr);
+	}
+	accept(visitor) {
+		return visitor.operator(this);
+	}
+	rewrite(rewriter) {
+		const { args } = this;
+		let rewrittenArgs;
+		if (isExprArray(args)) rewrittenArgs = args.map((a) => a.rewrite(rewriter));
+		else if (isRecordArgs(args)) rewrittenArgs = rewriteRecordArgs(args, rewriter);
+		else rewrittenArgs = args.rewrite(rewriter);
+		const rebuilt = new MongoAggOperator(this.op, rewrittenArgs);
+		return rewriter.operator ? rewriter.operator(rebuilt) : rebuilt;
+	}
+};
+var MongoAggAccumulator = class MongoAggAccumulator extends MongoAggExprNode {
+	kind = "accumulator";
+	op;
+	arg;
+	constructor(op, arg) {
+		super();
+		this.op = op;
+		if (arg !== null && isRecordArgs(arg)) this.arg = freezeRecordArgs(arg);
+		else this.arg = arg;
+		this.freeze();
+	}
+	static of(op, arg) {
+		return new MongoAggAccumulator(op, arg);
+	}
+	static sum(expr) {
+		return new MongoAggAccumulator("$sum", expr);
+	}
+	static avg(expr) {
+		return new MongoAggAccumulator("$avg", expr);
+	}
+	static min(expr) {
+		return new MongoAggAccumulator("$min", expr);
+	}
+	static max(expr) {
+		return new MongoAggAccumulator("$max", expr);
+	}
+	static first(expr) {
+		return new MongoAggAccumulator("$first", expr);
+	}
+	static last(expr) {
+		return new MongoAggAccumulator("$last", expr);
+	}
+	static push(expr) {
+		return new MongoAggAccumulator("$push", expr);
+	}
+	static addToSet(expr) {
+		return new MongoAggAccumulator("$addToSet", expr);
+	}
+	static count() {
+		return new MongoAggAccumulator("$count", null);
+	}
+	static stdDevPop(expr) {
+		return new MongoAggAccumulator("$stdDevPop", expr);
+	}
+	static stdDevSamp(expr) {
+		return new MongoAggAccumulator("$stdDevSamp", expr);
+	}
+	accept(visitor) {
+		return visitor.accumulator(this);
+	}
+	rewrite(rewriter) {
+		let rewrittenArg;
+		if (this.arg === null) rewrittenArg = null;
+		else if (isRecordArgs(this.arg)) rewrittenArg = rewriteRecordArgs(this.arg, rewriter);
+		else rewrittenArg = this.arg.rewrite(rewriter);
+		const rebuilt = new MongoAggAccumulator(this.op, rewrittenArg);
+		return rewriter.accumulator ? rewriter.accumulator(rebuilt) : rebuilt;
+	}
+};
+var MongoAggCond = class MongoAggCond extends MongoAggExprNode {
+	kind = "cond";
+	condition;
+	then_;
+	else_;
+	constructor(condition, then_, else_) {
+		super();
+		this.condition = condition;
+		this.then_ = then_;
+		this.else_ = else_;
+		this.freeze();
+	}
+	static of(condition, then_, else_) {
+		return new MongoAggCond(condition, then_, else_);
+	}
+	accept(visitor) {
+		return visitor.cond(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggCond(this.condition.rewrite(rewriter), this.then_.rewrite(rewriter), this.else_.rewrite(rewriter));
+		return rewriter.cond ? rewriter.cond(rebuilt) : rebuilt;
+	}
+};
+var MongoAggSwitch = class MongoAggSwitch extends MongoAggExprNode {
+	kind = "switch";
+	branches;
+	default_;
+	constructor(branches, default_) {
+		super();
+		this.branches = Object.freeze(branches.map((b) => Object.freeze({
+			case_: b.case_,
+			then_: b.then_
+		})));
+		this.default_ = default_;
+		this.freeze();
+	}
+	static of(branches, default_) {
+		return new MongoAggSwitch(branches, default_);
+	}
+	accept(visitor) {
+		return visitor.switch_(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggSwitch(this.branches.map((b) => ({
+			case_: b.case_.rewrite(rewriter),
+			then_: b.then_.rewrite(rewriter)
+		})), this.default_.rewrite(rewriter));
+		return rewriter.switch_ ? rewriter.switch_(rebuilt) : rebuilt;
+	}
+};
+var MongoAggArrayFilter = class MongoAggArrayFilter extends MongoAggExprNode {
+	kind = "filter";
+	input;
+	cond;
+	as;
+	constructor(input, cond, as) {
+		super();
+		this.input = input;
+		this.cond = cond;
+		this.as = as;
+		this.freeze();
+	}
+	static of(input, cond, as) {
+		return new MongoAggArrayFilter(input, cond, as);
+	}
+	accept(visitor) {
+		return visitor.filter(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggArrayFilter(this.input.rewrite(rewriter), this.cond.rewrite(rewriter), this.as);
+		return rewriter.filter ? rewriter.filter(rebuilt) : rebuilt;
+	}
+};
+var MongoAggMap = class MongoAggMap extends MongoAggExprNode {
+	kind = "map";
+	input;
+	in_;
+	as;
+	constructor(input, in_, as) {
+		super();
+		this.input = input;
+		this.in_ = in_;
+		this.as = as;
+		this.freeze();
+	}
+	static of(input, in_, as) {
+		return new MongoAggMap(input, in_, as);
+	}
+	accept(visitor) {
+		return visitor.map(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggMap(this.input.rewrite(rewriter), this.in_.rewrite(rewriter), this.as);
+		return rewriter.map ? rewriter.map(rebuilt) : rebuilt;
+	}
+};
+var MongoAggReduce = class MongoAggReduce extends MongoAggExprNode {
+	kind = "reduce";
+	input;
+	initialValue;
+	in_;
+	constructor(input, initialValue, in_) {
+		super();
+		this.input = input;
+		this.initialValue = initialValue;
+		this.in_ = in_;
+		this.freeze();
+	}
+	static of(input, initialValue, in_) {
+		return new MongoAggReduce(input, initialValue, in_);
+	}
+	accept(visitor) {
+		return visitor.reduce(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggReduce(this.input.rewrite(rewriter), this.initialValue.rewrite(rewriter), this.in_.rewrite(rewriter));
+		return rewriter.reduce ? rewriter.reduce(rebuilt) : rebuilt;
+	}
+};
+var MongoAggLet = class MongoAggLet extends MongoAggExprNode {
+	kind = "let";
+	vars;
+	in_;
+	constructor(vars, in_) {
+		super();
+		this.vars = Object.freeze({ ...vars });
+		this.in_ = in_;
+		this.freeze();
+	}
+	static of(vars, in_) {
+		return new MongoAggLet(vars, in_);
+	}
+	accept(visitor) {
+		return visitor.let_(this);
+	}
+	rewrite(rewriter) {
+		const rewrittenVars = {};
+		for (const [key, val] of Object.entries(this.vars)) rewrittenVars[key] = val.rewrite(rewriter);
+		const rebuilt = new MongoAggLet(rewrittenVars, this.in_.rewrite(rewriter));
+		return rewriter.let_ ? rewriter.let_(rebuilt) : rebuilt;
+	}
+};
+var MongoAggMergeObjects = class MongoAggMergeObjects extends MongoAggExprNode {
+	kind = "mergeObjects";
+	exprs;
+	constructor(exprs) {
+		super();
+		this.exprs = Object.freeze([...exprs]);
+		this.freeze();
+	}
+	static of(exprs) {
+		return new MongoAggMergeObjects(exprs);
+	}
+	accept(visitor) {
+		return visitor.mergeObjects(this);
+	}
+	rewrite(rewriter) {
+		const rebuilt = new MongoAggMergeObjects(this.exprs.map((e) => e.rewrite(rewriter)));
+		return rewriter.mergeObjects ? rewriter.mergeObjects(rebuilt) : rebuilt;
+	}
+};
+var InsertOneCommand = class extends MongoAstNode {
+	kind = "insertOne";
+	collection;
+	document;
+	constructor(collection, document) {
+		super();
+		this.collection = collection;
+		this.document = document;
+		this.freeze();
+	}
+};
+var UpdateOneCommand = class extends MongoAstNode {
+	kind = "updateOne";
+	collection;
+	filter;
+	update;
+	/**
+	* When true, the wire command becomes an upsert: if no document matches
+	* `filter`, a new document is inserted, derived from the filter's
+	* equality fields plus the update spec. Defaults to false.
+	*/
+	upsert;
+	constructor(collection, filter, update, upsert = false) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.freeze();
+	}
+};
+var DeleteOneCommand = class extends MongoAstNode {
+	kind = "deleteOne";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+var InsertManyCommand = class extends MongoAstNode {
+	kind = "insertMany";
+	collection;
+	documents;
+	constructor(collection, documents) {
+		super();
+		this.collection = collection;
+		this.documents = documents;
+		this.freeze();
+	}
+};
+var UpdateManyCommand = class extends MongoAstNode {
+	kind = "updateMany";
+	collection;
+	filter;
+	update;
+	/**
+	* Upsert flag — see `UpdateOneCommand.upsert`. For `updateMany`, Mongo
+	* inserts at most one document when no match exists (driver-side
+	* constraint).
+	*/
+	upsert;
+	constructor(collection, filter, update, upsert = false) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.freeze();
+	}
+};
+var DeleteManyCommand = class extends MongoAstNode {
+	kind = "deleteMany";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+var FindOneAndUpdateCommand = class extends MongoAstNode {
+	kind = "findOneAndUpdate";
+	collection;
+	filter;
+	update;
+	upsert;
+	sort;
+	returnDocument;
+	constructor(collection, filter, update, upsert = false, sort, returnDocument = "after") {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.sort = sort;
+		this.returnDocument = returnDocument;
+		this.freeze();
+	}
+};
+var FindOneAndDeleteCommand = class extends MongoAstNode {
+	kind = "findOneAndDelete";
+	collection;
+	filter;
+	sort;
+	constructor(collection, filter, sort) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.sort = sort;
+		this.freeze();
+	}
+};
+var AggregateCommand = class extends MongoAstNode {
+	kind = "aggregate";
+	collection;
+	pipeline;
+	constructor(collection, pipeline) {
+		super();
+		this.collection = collection;
+		this.pipeline = pipeline;
+		this.freeze();
+	}
+};
+var RawAggregateCommand = class extends MongoAstNode {
+	kind = "rawAggregate";
+	collection;
+	pipeline;
+	constructor(collection, pipeline) {
+		super();
+		this.collection = collection;
+		this.pipeline = pipeline;
+		this.freeze();
+	}
+};
+var RawInsertOneCommand = class extends MongoAstNode {
+	kind = "rawInsertOne";
+	collection;
+	document;
+	constructor(collection, document) {
+		super();
+		this.collection = collection;
+		this.document = document;
+		this.freeze();
+	}
+};
+var RawInsertManyCommand = class extends MongoAstNode {
+	kind = "rawInsertMany";
+	collection;
+	documents;
+	constructor(collection, documents) {
+		super();
+		this.collection = collection;
+		this.documents = documents;
+		this.freeze();
+	}
+};
+var RawUpdateOneCommand = class extends MongoAstNode {
+	kind = "rawUpdateOne";
+	collection;
+	filter;
+	update;
+	constructor(collection, filter, update) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.freeze();
+	}
+};
+var RawUpdateManyCommand = class extends MongoAstNode {
+	kind = "rawUpdateMany";
+	collection;
+	filter;
+	update;
+	constructor(collection, filter, update) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.freeze();
+	}
+};
+var RawDeleteOneCommand = class extends MongoAstNode {
+	kind = "rawDeleteOne";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+var RawDeleteManyCommand = class extends MongoAstNode {
+	kind = "rawDeleteMany";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+var RawFindOneAndUpdateCommand = class extends MongoAstNode {
+	kind = "rawFindOneAndUpdate";
+	collection;
+	filter;
+	update;
+	upsert;
+	sort;
+	/**
+	* When `undefined`, the option is omitted from the wire command and the
+	* MongoDB driver applies its documented default (return the pre-image
+	* document). Set explicitly to `'before'` or `'after'` to override.
+	*/
+	returnDocument;
+	constructor(collection, filter, update, upsert = false, sort, returnDocument) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.sort = sort;
+		this.returnDocument = returnDocument;
+		this.freeze();
+	}
+};
+var RawFindOneAndDeleteCommand = class extends MongoAstNode {
+	kind = "rawFindOneAndDelete";
+	collection;
+	filter;
+	sort;
+	constructor(collection, filter, sort) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.sort = sort;
+		this.freeze();
+	}
+};
+function freezeMongoFieldShape(shape) {
+	switch (shape.kind) {
+		case "unknown": return Object.freeze({ kind: "unknown" });
+		case "leaf": return Object.freeze({
+			kind: "leaf",
+			codecId: shape.codecId,
+			nullable: shape.nullable
+		});
+		case "document": {
+			const fields = {};
+			for (const [k, v] of Object.entries(shape.fields)) fields[k] = freezeMongoFieldShape(v);
+			return Object.freeze({
+				kind: "document",
+				nullable: shape.nullable,
+				fields: Object.freeze(fields)
+			});
+		}
+		case "array": return Object.freeze({
+			kind: "array",
+			nullable: shape.nullable,
+			element: freezeMongoFieldShape(shape.element)
+		});
+		default: return shape;
+	}
+}
+function freezeMongoResultShape(shape) {
+	if (shape.kind === "unknown") return Object.freeze({ kind: "unknown" });
+	const fields = {};
+	for (const [k, v] of Object.entries(shape.fields)) fields[k] = freezeMongoFieldShape(v);
+	return Object.freeze({
+		kind: "document",
+		fields: Object.freeze(fields)
+	});
+}
+function isAggExpr(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
+function isAggExprNode(value) {
+	return "accept" in value && typeof value.accept === "function";
+}
+function rewriteGroupId(groupId, rewriter) {
+	if (groupId === null) return null;
+	if (isAggExprNode(groupId)) return groupId.rewrite(rewriter);
+	const result = {};
+	for (const [key, val] of Object.entries(groupId)) result[key] = val.rewrite(rewriter);
+	return result;
+}
+function rewriteExprRecord(fields, rewriter) {
+	const result = {};
+	for (const [key, val] of Object.entries(fields)) result[key] = val.rewrite(rewriter);
+	return result;
+}
+function rewriteAccumulatorRecord(accumulators, rewriter) {
+	const result = {};
+	for (const [key, acc] of Object.entries(accumulators)) result[key] = acc.rewrite(rewriter);
+	return result;
+}
+var MongoStageNode = class extends MongoAstNode {};
+var MongoMatchStage = class MongoMatchStage extends MongoStageNode {
+	kind = "match";
+	filter;
+	constructor(filter) {
+		super();
+		this.filter = filter;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.match(this);
+	}
+	rewrite(context) {
+		return new MongoMatchStage(this.filter.rewrite(context.filter ?? {}));
+	}
+};
+var MongoProjectStage = class MongoProjectStage extends MongoStageNode {
+	kind = "project";
+	projection;
+	constructor(projection) {
+		super();
+		this.projection = Object.freeze({ ...projection });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.project(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		let hasExpr = false;
+		for (const val of Object.values(this.projection)) if (isAggExpr(val)) {
+			hasExpr = true;
+			break;
+		}
+		if (!hasExpr) return this;
+		const newProjection = {};
+		for (const [key, val] of Object.entries(this.projection)) newProjection[key] = isAggExpr(val) ? val.rewrite(rewriter) : val;
+		return new MongoProjectStage(newProjection);
+	}
+};
+var MongoSortStage = class extends MongoStageNode {
+	kind = "sort";
+	sort;
+	constructor(sort) {
+		super();
+		this.sort = Object.freeze({ ...sort });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.sort(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoLimitStage = class extends MongoStageNode {
+	kind = "limit";
+	limit;
+	constructor(limit) {
+		super();
+		if (!Number.isInteger(limit) || limit < 0) throw ormError("ORM.ARGUMENT_INVALID", "limit must be a non-negative integer");
+		this.limit = limit;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.limit(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoSkipStage = class extends MongoStageNode {
+	kind = "skip";
+	skip;
+	constructor(skip) {
+		super();
+		if (!Number.isInteger(skip) || skip < 0) throw ormError("ORM.ARGUMENT_INVALID", "skip must be a non-negative integer");
+		this.skip = skip;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.skip(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoLookupStage = class MongoLookupStage extends MongoStageNode {
+	kind = "lookup";
+	from;
+	localField;
+	foreignField;
+	as;
+	pipeline;
+	let_;
+	constructor(options) {
+		super();
+		const hasLocalField = options.localField !== void 0;
+		const hasForeignField = options.foreignField !== void 0;
+		const hasPipeline = !!options.pipeline;
+		if (hasLocalField !== hasForeignField) throw ormError("ORM.ARGUMENT_INVALID", "MongoLookupStage requires both localField and foreignField together");
+		if (!hasLocalField && !hasPipeline) throw ormError("ORM.ARGUMENT_INVALID", "MongoLookupStage requires either equality fields (localField/foreignField) or a pipeline");
+		if (options.let_ && !hasPipeline) throw ormError("ORM.ARGUMENT_INVALID", "MongoLookupStage let_ requires a pipeline");
+		this.from = options.from;
+		this.localField = options.localField;
+		this.foreignField = options.foreignField;
+		this.as = options.as;
+		this.pipeline = options.pipeline ? Object.freeze([...options.pipeline]) : void 0;
+		this.let_ = options.let_ ? Object.freeze({ ...options.let_ }) : void 0;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.lookup(this);
+	}
+	rewrite(context) {
+		if (!this.pipeline && !this.let_) return this;
+		const rewrittenLet = this.let_ && context.aggExpr ? rewriteExprRecord(this.let_, context.aggExpr) : this.let_;
+		const options = {
+			from: this.from,
+			as: this.as
+		};
+		if (this.localField !== void 0) options.localField = this.localField;
+		if (this.foreignField !== void 0) options.foreignField = this.foreignField;
+		if (this.pipeline) options.pipeline = this.pipeline.map((stage) => stage.rewrite(context));
+		if (rewrittenLet) options.let_ = { ...rewrittenLet };
+		return new MongoLookupStage(options);
+	}
+};
+var MongoUnwindStage = class extends MongoStageNode {
+	kind = "unwind";
+	path;
+	preserveNullAndEmptyArrays;
+	includeArrayIndex;
+	constructor(path, preserveNullAndEmptyArrays, includeArrayIndex) {
+		super();
+		this.path = path;
+		this.preserveNullAndEmptyArrays = preserveNullAndEmptyArrays;
+		this.includeArrayIndex = includeArrayIndex;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.unwind(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoGroupStage = class MongoGroupStage extends MongoStageNode {
+	kind = "group";
+	groupId;
+	accumulators;
+	constructor(groupId, accumulators) {
+		super();
+		this.groupId = groupId;
+		this.accumulators = Object.freeze({ ...accumulators });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.group(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		const newAccumulators = {};
+		for (const [key, acc] of Object.entries(this.accumulators)) newAccumulators[key] = acc.rewrite(rewriter);
+		return new MongoGroupStage(rewriteGroupId(this.groupId, rewriter), newAccumulators);
+	}
+};
+var MongoAddFieldsStage = class MongoAddFieldsStage extends MongoStageNode {
+	kind = "addFields";
+	fields;
+	constructor(fields) {
+		super();
+		this.fields = Object.freeze({ ...fields });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.addFields(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		return new MongoAddFieldsStage(rewriteExprRecord(this.fields, rewriter));
+	}
+};
+var MongoReplaceRootStage = class MongoReplaceRootStage extends MongoStageNode {
+	kind = "replaceRoot";
+	newRoot;
+	constructor(newRoot) {
+		super();
+		this.newRoot = newRoot;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.replaceRoot(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		return new MongoReplaceRootStage(this.newRoot.rewrite(rewriter));
+	}
+};
+var MongoCountStage = class extends MongoStageNode {
+	kind = "count";
+	field;
+	constructor(field) {
+		super();
+		this.field = field;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.count(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoSortByCountStage = class MongoSortByCountStage extends MongoStageNode {
+	kind = "sortByCount";
+	expr;
+	constructor(expr) {
+		super();
+		this.expr = expr;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.sortByCount(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		return new MongoSortByCountStage(this.expr.rewrite(rewriter));
+	}
+};
+var MongoSampleStage = class extends MongoStageNode {
+	kind = "sample";
+	size;
+	constructor(size) {
+		super();
+		if (!Number.isInteger(size) || size < 0) throw ormError("ORM.ARGUMENT_INVALID", "size must be a non-negative integer");
+		this.size = size;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.sample(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoRedactStage = class MongoRedactStage extends MongoStageNode {
+	kind = "redact";
+	expr;
+	constructor(expr) {
+		super();
+		this.expr = expr;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.redact(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		return new MongoRedactStage(this.expr.rewrite(rewriter));
+	}
+};
+var MongoOutStage = class extends MongoStageNode {
+	kind = "out";
+	collection;
+	db;
+	constructor(collection, db) {
+		super();
+		this.collection = collection;
+		this.db = db;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.out(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoUnionWithStage = class MongoUnionWithStage extends MongoStageNode {
+	kind = "unionWith";
+	collection;
+	pipeline;
+	constructor(collection, pipeline) {
+		super();
+		this.collection = collection;
+		this.pipeline = pipeline ? Object.freeze([...pipeline]) : void 0;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.unionWith(this);
+	}
+	rewrite(context) {
+		if (!this.pipeline) return this;
+		return new MongoUnionWithStage(this.collection, this.pipeline.map((stage) => stage.rewrite(context)));
+	}
+};
+var MongoBucketStage = class MongoBucketStage extends MongoStageNode {
+	kind = "bucket";
+	groupBy;
+	boundaries;
+	default_;
+	output;
+	constructor(options) {
+		super();
+		if (options.boundaries.length < 2) throw ormError("ORM.ARGUMENT_INVALID", "boundaries must contain at least 2 values");
+		this.groupBy = options.groupBy;
+		this.boundaries = Object.freeze([...options.boundaries]);
+		this.default_ = options.default_;
+		this.output = options.output ? Object.freeze({ ...options.output }) : void 0;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.bucket(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		const opts = {
+			groupBy: this.groupBy.rewrite(rewriter),
+			boundaries: this.boundaries
+		};
+		if (this.default_ !== void 0) opts.default_ = this.default_;
+		if (this.output) opts.output = rewriteAccumulatorRecord(this.output, rewriter);
+		return new MongoBucketStage(opts);
+	}
+};
+var MongoBucketAutoStage = class MongoBucketAutoStage extends MongoStageNode {
+	kind = "bucketAuto";
+	groupBy;
+	buckets;
+	output;
+	granularity;
+	constructor(options) {
+		super();
+		if (!Number.isInteger(options.buckets) || options.buckets < 1) throw ormError("ORM.ARGUMENT_INVALID", "buckets must be a positive integer");
+		this.groupBy = options.groupBy;
+		this.buckets = options.buckets;
+		this.output = options.output ? Object.freeze({ ...options.output }) : void 0;
+		this.granularity = options.granularity;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.bucketAuto(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		const opts = {
+			groupBy: this.groupBy.rewrite(rewriter),
+			buckets: this.buckets
+		};
+		if (this.output) opts.output = rewriteAccumulatorRecord(this.output, rewriter);
+		if (this.granularity !== void 0) opts.granularity = this.granularity;
+		return new MongoBucketAutoStage(opts);
+	}
+};
+var MongoGeoNearStage = class MongoGeoNearStage extends MongoStageNode {
+	kind = "geoNear";
+	near;
+	distanceField;
+	spherical;
+	maxDistance;
+	minDistance;
+	query;
+	key;
+	distanceMultiplier;
+	includeLocs;
+	constructor(options) {
+		super();
+		this.near = options.near;
+		this.distanceField = options.distanceField;
+		this.spherical = options.spherical;
+		this.maxDistance = options.maxDistance;
+		this.minDistance = options.minDistance;
+		this.query = options.query;
+		this.key = options.key;
+		this.distanceMultiplier = options.distanceMultiplier;
+		this.includeLocs = options.includeLocs;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.geoNear(this);
+	}
+	rewrite(context) {
+		if (!this.query || !context.filter) return this;
+		const opts = {
+			near: this.near,
+			distanceField: this.distanceField
+		};
+		if (this.spherical !== void 0) opts.spherical = this.spherical;
+		if (this.maxDistance !== void 0) opts.maxDistance = this.maxDistance;
+		if (this.minDistance !== void 0) opts.minDistance = this.minDistance;
+		opts.query = this.query.rewrite(context.filter);
+		if (this.key !== void 0) opts.key = this.key;
+		if (this.distanceMultiplier !== void 0) opts.distanceMultiplier = this.distanceMultiplier;
+		if (this.includeLocs !== void 0) opts.includeLocs = this.includeLocs;
+		return new MongoGeoNearStage(opts);
+	}
+};
+var MongoFacetStage = class MongoFacetStage extends MongoStageNode {
+	kind = "facet";
+	facets;
+	constructor(facets) {
+		super();
+		const frozen = {};
+		for (const [key, pipeline] of Object.entries(facets)) frozen[key] = Object.freeze([...pipeline]);
+		this.facets = Object.freeze(frozen);
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.facet(this);
+	}
+	rewrite(context) {
+		const newFacets = {};
+		for (const [key, pipeline] of Object.entries(this.facets)) newFacets[key] = pipeline.map((stage) => stage.rewrite(context));
+		return new MongoFacetStage(newFacets);
+	}
+};
+var MongoGraphLookupStage = class MongoGraphLookupStage extends MongoStageNode {
+	kind = "graphLookup";
+	from;
+	startWith;
+	connectFromField;
+	connectToField;
+	as;
+	maxDepth;
+	depthField;
+	restrictSearchWithMatch;
+	constructor(options) {
+		super();
+		this.from = options.from;
+		this.startWith = options.startWith;
+		this.connectFromField = options.connectFromField;
+		this.connectToField = options.connectToField;
+		this.as = options.as;
+		this.maxDepth = options.maxDepth;
+		this.depthField = options.depthField;
+		this.restrictSearchWithMatch = options.restrictSearchWithMatch;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.graphLookup(this);
+	}
+	rewrite(context) {
+		const rewrittenStartWith = context.aggExpr ? this.startWith.rewrite(context.aggExpr) : this.startWith;
+		const rewrittenMatch = this.restrictSearchWithMatch && context.filter ? this.restrictSearchWithMatch.rewrite(context.filter) : this.restrictSearchWithMatch;
+		if (rewrittenStartWith === this.startWith && rewrittenMatch === this.restrictSearchWithMatch) return this;
+		const opts = {
+			from: this.from,
+			startWith: rewrittenStartWith,
+			connectFromField: this.connectFromField,
+			connectToField: this.connectToField,
+			as: this.as
+		};
+		if (this.maxDepth !== void 0) opts.maxDepth = this.maxDepth;
+		if (this.depthField !== void 0) opts.depthField = this.depthField;
+		if (rewrittenMatch) opts.restrictSearchWithMatch = rewrittenMatch;
+		return new MongoGraphLookupStage(opts);
+	}
+};
+var MongoMergeStage = class MongoMergeStage extends MongoStageNode {
+	kind = "merge";
+	into;
+	on;
+	whenMatched;
+	whenNotMatched;
+	constructor(options) {
+		super();
+		this.into = typeof options.into === "string" ? options.into : Object.freeze({ ...options.into });
+		this.on = options.on === void 0 ? void 0 : typeof options.on === "string" ? options.on : Object.freeze([...options.on]);
+		this.whenMatched = options.whenMatched === void 0 ? void 0 : typeof options.whenMatched === "string" ? options.whenMatched : Object.freeze([...options.whenMatched]);
+		this.whenNotMatched = options.whenNotMatched;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.merge(this);
+	}
+	rewrite(context) {
+		if (!Array.isArray(this.whenMatched)) return this;
+		const opts = { into: this.into };
+		if (this.on !== void 0) opts.on = this.on;
+		opts.whenMatched = this.whenMatched.map((stage) => stage.rewrite(context));
+		if (this.whenNotMatched !== void 0) opts.whenNotMatched = this.whenNotMatched;
+		return new MongoMergeStage(opts);
+	}
+};
+var MongoSetWindowFieldsStage = class MongoSetWindowFieldsStage extends MongoStageNode {
+	kind = "setWindowFields";
+	partitionBy;
+	sortBy;
+	output;
+	constructor(options) {
+		super();
+		this.partitionBy = options.partitionBy;
+		this.sortBy = options.sortBy ? Object.freeze({ ...options.sortBy }) : void 0;
+		this.output = Object.freeze({ ...options.output });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.setWindowFields(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		const newOutput = {};
+		for (const [key, wf] of Object.entries(this.output)) newOutput[key] = {
+			...wf,
+			operator: wf.operator.rewrite(rewriter)
+		};
+		const opts = { output: newOutput };
+		if (this.partitionBy) opts.partitionBy = this.partitionBy.rewrite(rewriter);
+		if (this.sortBy) opts.sortBy = { ...this.sortBy };
+		return new MongoSetWindowFieldsStage(opts);
+	}
+};
+var MongoDensifyStage = class extends MongoStageNode {
+	kind = "densify";
+	field;
+	partitionByFields;
+	range;
+	constructor(options) {
+		super();
+		this.field = options.field;
+		this.partitionByFields = options.partitionByFields ? Object.freeze([...options.partitionByFields]) : void 0;
+		this.range = Object.freeze({ ...options.range });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.densify(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoFillStage = class MongoFillStage extends MongoStageNode {
+	kind = "fill";
+	partitionBy;
+	partitionByFields;
+	sortBy;
+	output;
+	constructor(options) {
+		super();
+		this.partitionBy = options.partitionBy;
+		this.partitionByFields = options.partitionByFields ? Object.freeze([...options.partitionByFields]) : void 0;
+		this.sortBy = options.sortBy ? Object.freeze({ ...options.sortBy }) : void 0;
+		this.output = Object.freeze({ ...options.output });
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.fill(this);
+	}
+	rewrite(context) {
+		const rewriter = context.aggExpr;
+		if (!rewriter) return this;
+		const newOutput = {};
+		for (const [key, fo] of Object.entries(this.output)) newOutput[key] = fo.value ? {
+			...fo,
+			value: fo.value.rewrite(rewriter)
+		} : fo;
+		const opts = { output: newOutput };
+		if (this.partitionBy) opts.partitionBy = this.partitionBy.rewrite(rewriter);
+		if (this.partitionByFields) opts.partitionByFields = [...this.partitionByFields];
+		if (this.sortBy) opts.sortBy = { ...this.sortBy };
+		return new MongoFillStage(opts);
+	}
+};
+var MongoSearchStage = class extends MongoStageNode {
+	kind = "search";
+	index;
+	config;
+	constructor(config, index) {
+		super();
+		this.config = Object.freeze({ ...config });
+		this.index = index;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.search(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoSearchMetaStage = class extends MongoStageNode {
+	kind = "searchMeta";
+	index;
+	config;
+	constructor(config, index) {
+		super();
+		this.config = Object.freeze({ ...config });
+		this.index = index;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.searchMeta(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+var MongoVectorSearchStage = class extends MongoStageNode {
+	kind = "vectorSearch";
+	index;
+	path;
+	queryVector;
+	numCandidates;
+	limit;
+	filter;
+	constructor(options) {
+		super();
+		if (!Number.isInteger(options.limit) || options.limit < 1) throw ormError("ORM.ARGUMENT_INVALID", "limit must be a positive integer");
+		if (!Number.isInteger(options.numCandidates) || options.numCandidates < options.limit) throw ormError("ORM.ARGUMENT_INVALID", "numCandidates must be an integer >= limit");
+		this.index = options.index;
+		this.path = options.path;
+		this.queryVector = Object.freeze([...options.queryVector]);
+		this.numCandidates = options.numCandidates;
+		this.limit = options.limit;
+		this.filter = options.filter ? Object.freeze({ ...options.filter }) : void 0;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.vectorSearch(this);
+	}
+	rewrite(_context) {
+		return this;
+	}
+};
+//#endregion
+export { RawInsertOneCommand as $, MongoLookupStage as A, MongoSetWindowFieldsStage as B, MongoDensifyStage as C, MongoGraphLookupStage as D, MongoGeoNearStage as E, MongoRedactStage as F, MongoUnwindStage as G, MongoSortByCountStage as H, MongoReplaceRootStage as I, RawDeleteManyCommand as J, MongoVectorSearchStage as K, MongoSampleStage as L, MongoMergeStage as M, MongoOutStage as N, MongoGroupStage as O, MongoProjectStage as P, RawInsertManyCommand as Q, MongoSearchMetaStage as R, MongoCountStage as S, MongoFillStage as T, MongoSortStage as U, MongoSkipStage as V, MongoUnionWithStage as W, RawFindOneAndDeleteCommand as X, RawDeleteOneCommand as Y, RawFindOneAndUpdateCommand as Z, MongoAggOperator as _, FindOneAndUpdateCommand as a, freezeMongoResultShape as at, MongoBucketAutoStage as b, MongoAddFieldsStage as c, MongoAggCond as d, RawUpdateManyCommand as et, MongoAggFieldRef as f, MongoAggMergeObjects as g, MongoAggMap as h, FindOneAndDeleteCommand as i, freezeMongoFieldShape as it, MongoMatchStage as j, MongoLimitStage as k, MongoAggAccumulator as l, MongoAggLiteral as m, DeleteManyCommand as n, UpdateManyCommand as nt, InsertManyCommand as o, isExprArray as ot, MongoAggLet as p, RawAggregateCommand as q, DeleteOneCommand as r, UpdateOneCommand as rt, InsertOneCommand as s, isRecordArgs as st, AggregateCommand as t, RawUpdateOneCommand as tt, MongoAggArrayFilter as u, MongoAggReduce as v, MongoFacetStage as w, MongoBucketStage as x, MongoAggSwitch as y, MongoSearchStage as z };
+
+//# sourceMappingURL=execution-D5XyZ5XS.mjs.map