@prisma-next/mongo-query-ast 0.0.1 → 0.3.0-dev.147

package/dist/exports/index.mjs

@@ -0,0 +1,1374 @@
+//#region src/ast-node.ts
+var MongoAstNode = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+
+//#endregion
+//#region src/aggregation-expressions.ts
+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 new Error("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;
+	}
+};
+
+//#endregion
+//#region src/commands.ts
+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;
+	constructor(collection, filter, update) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		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;
+	constructor(collection, filter, update) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		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;
+	constructor(collection, filter, update, upsert) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.freeze();
+	}
+};
+var FindOneAndDeleteCommand = class extends MongoAstNode {
+	kind = "findOneAndDelete";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+var AggregateCommand = class extends MongoAstNode {
+	kind = "aggregate";
+	collection;
+	pipeline;
+	constructor(collection, pipeline) {
+		super();
+		this.collection = collection;
+		this.pipeline = pipeline;
+		this.freeze();
+	}
+};
+
+//#endregion
+//#region src/filter-expressions.ts
+var MongoFilterExpression = class extends MongoAstNode {
+	not() {
+		return new MongoNotExpr(this);
+	}
+};
+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 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 new Error("$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 new Error("$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
+//#region src/raw-commands.ts
+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;
+	constructor(collection, filter, update, upsert) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.update = update;
+		this.upsert = upsert;
+		this.freeze();
+	}
+};
+var RawFindOneAndDeleteCommand = class extends MongoAstNode {
+	kind = "rawFindOneAndDelete";
+	collection;
+	filter;
+	constructor(collection, filter) {
+		super();
+		this.collection = collection;
+		this.filter = filter;
+		this.freeze();
+	}
+};
+
+//#endregion
+//#region src/stages.ts
+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 new RangeError("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 new RangeError("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 new Error("MongoLookupStage requires both localField and foreignField together");
+		if (!hasLocalField && !hasPipeline) throw new Error("MongoLookupStage requires either equality fields (localField/foreignField) or a pipeline");
+		if (options.let_ && !hasPipeline) throw new Error("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 new RangeError("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 new RangeError("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 new RangeError("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 new RangeError("limit must be a positive integer");
+		if (!Number.isInteger(options.numCandidates) || options.numCandidates < options.limit) throw new RangeError("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 { AggregateCommand, DeleteManyCommand, DeleteOneCommand, FindOneAndDeleteCommand, FindOneAndUpdateCommand, InsertManyCommand, InsertOneCommand, MongoAddFieldsStage, MongoAggAccumulator, MongoAggArrayFilter, MongoAggCond, MongoAggFieldRef, MongoAggLet, MongoAggLiteral, MongoAggMap, MongoAggMergeObjects, MongoAggOperator, MongoAggReduce, MongoAggSwitch, MongoAndExpr, MongoBucketAutoStage, MongoBucketStage, MongoCountStage, MongoDensifyStage, MongoExistsExpr, MongoExprFilter, MongoFacetStage, MongoFieldFilter, MongoFillStage, MongoGeoNearStage, MongoGraphLookupStage, MongoGroupStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoNotExpr, MongoOrExpr, MongoOutStage, MongoProjectStage, MongoRedactStage, MongoReplaceRootStage, MongoSampleStage, MongoSearchMetaStage, MongoSearchStage, MongoSetWindowFieldsStage, MongoSkipStage, MongoSortByCountStage, MongoSortStage, MongoUnionWithStage, MongoUnwindStage, MongoVectorSearchStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand, UpdateManyCommand, UpdateOneCommand, isExprArray, isRecordArgs };
+//# sourceMappingURL=index.mjs.map