sluice-orm 0.1.0

package/dist/index.js

@@ -0,0 +1,911 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/accumulator-utils.ts
+var functionToString = (fn) => {
+  const fnStr = fn.toString();
+  if (!fnStr.includes("=>")) return fnStr;
+  const paramMatch = /^(?:\(([^)]*)\)|(\w+))\s*=>/.exec(fnStr);
+  if (!paramMatch) throw new Error(`Cannot parse arrow function parameters: ${fnStr}`);
+  const params = paramMatch[1] ?? paramMatch[2];
+  const arrowIndex = fnStr.indexOf("=>");
+  const body = fnStr.slice(arrowIndex + 2).trim();
+  const hasBlock = body.startsWith("{");
+  return hasBlock ? `function(${params}) ${body}` : `function(${params}) { return ${body}; }`;
+};
+var resolveAccumulator = (config) => {
+  const result = {
+    init: functionToString(config.init),
+    initArgs: config.initArgs,
+    accumulate: functionToString(config.accumulate),
+    accumulateArgs: config.accumulateArgs,
+    merge: functionToString(config.merge),
+    lang: config.lang
+  };
+  return config.finalize ? { ...result, finalize: functionToString(config.finalize) } : result;
+};
+
+// src/builder.ts
+import { ObjectId } from "mongodb";
+var Ret = class {
+  constructor(__fn, __minVersion = "") {
+    this.__fn = __fn;
+    this.__minVersion = __minVersion;
+    __publicField(this, "__context");
+    __publicField(this, "__type");
+    __publicField(this, "__tag", "Ret");
+  }
+};
+var BaseBuilder = class {
+  constructor() {
+    // Identity: single argument passed through
+    __publicField(this, "id", (op) => (arg) => new Ret({ [`$${op}`]: this._resolve(arg) }));
+    // Varargs: multiple arguments as array
+    __publicField(this, "varargs", (op) => (...args) => new Ret({ [`$${op}`]: args.map((arg) => this._resolve(arg)) }));
+    // Flexible: 1 arg -> raw value, >1 args -> array (for operators that are both unary accumulators and variadic expressions)
+    __publicField(this, "flexible", (op) => (...args) => new Ret({
+      [`$${op}`]: args.length === 1 ? this._resolve(args[0]) : args.map(this._resolve.bind(this))
+    }));
+    // Options: single object argument
+    __publicField(this, "options", (op) => (options) => new Ret({ [`$${op}`]: this._resolve(options) }));
+    // Nullary: no arguments
+    __publicField(this, "nullary", (op) => () => new Ret({ [`$${op}`]: {} }));
+    // Pipeline builder for $facet and sub-pipelines
+    __publicField(this, "pipe", ((...stages) => stages.reduce((agg, stageFn) => stageFn(agg), {
+      stages: []
+    })));
+    // Query helper for $match array element filters
+    __publicField(this, "elemMatch", (filter) => ({
+      $elemMatch: filter(new ExprBuilder())
+    }));
+    // ==========================================
+    // Arithmetic Operators
+    // ==========================================
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/add/
+    __publicField(this, "add", this.varargs("add"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/subtract/
+    __publicField(this, "subtract", this.varargs("subtract"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/multiply/
+    __publicField(this, "multiply", this.varargs("multiply"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/divide/
+    __publicField(this, "divide", this.varargs("divide"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/mod/
+    __publicField(this, "mod", this.varargs("mod"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/abs/
+    __publicField(this, "abs", this.id("abs"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/ceil/
+    __publicField(this, "ceil", this.id("ceil"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/floor/
+    __publicField(this, "floor", this.id("floor"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/ln/
+    __publicField(this, "ln", this.id("ln"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/log/
+    __publicField(this, "log", this.varargs("log"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/log10/
+    __publicField(this, "log10", this.id("log10"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/pow/
+    __publicField(this, "pow", this.varargs("pow"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sqrt/
+    __publicField(this, "sqrt", this.id("sqrt"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/trunc/
+    __publicField(this, "trunc", (num, place) => place !== void 0 ? this.varargs("trunc")(num, place) : this.options("trunc")(num));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/round/
+    __publicField(this, "round", (num, place) => place !== void 0 ? this.varargs("round")(num, place) : this.options("round")(num));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/exp/
+    __publicField(this, "exp", this.id("exp"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/rand/
+    __publicField(this, "rand", this.nullary("rand"));
+    // ==========================================
+    // Array Operators
+    // ==========================================
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/arrayElemAt/
+    __publicField(this, "arrayElemAt", this.varargs("arrayElemAt"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/arrayToObject/
+    __publicField(this, "arrayToObject", this.id("arrayToObject"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/concatArrays/
+    __publicField(this, "concatArrays", this.varargs("concatArrays"));
+    /** Selects a subset of array elements that match a condition.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/filter/ */
+    __publicField(this, "filter", this.options("filter"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/first/
+    __publicField(this, "first", this.id("first"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/in/
+    __publicField(this, "in", this.varargs("in"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/indexOfArray/
+    __publicField(this, "indexOfArray", this.options("indexOfArray"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/isArray/
+    __publicField(this, "isArray", this.id("isArray"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/last/
+    __publicField(this, "last", this.id("last"));
+    /** Applies an expression to each element of an array and returns the results.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/map/ */
+    __publicField(this, "map", this.options("map"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN/
+    __publicField(this, "maxN", this.options("maxN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN/
+    __publicField(this, "minN", this.options("minN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN/
+    __publicField(this, "firstN", this.options("firstN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN/
+    __publicField(this, "lastN", this.options("lastN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/objectToArray/
+    __publicField(this, "objectToArray", this.id("objectToArray"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/range/
+    __publicField(this, "range", (start, end, step) => step !== void 0 ? this.varargs("range")(start, end, step) : this.varargs("range")(start, end));
+    /** Applies an expression to each element of an array, accumulating into a single value.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/reduce/ */
+    __publicField(this, "reduce", this.options("reduce"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/reverseArray/
+    __publicField(this, "reverseArray", this.id("reverseArray"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/size/
+    __publicField(this, "size", this.id("size"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/slice/
+    __publicField(this, "slice", (array, n, position) => position !== void 0 ? this.varargs("slice")(array, n, position) : this.varargs("slice")(array, n));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sortArray/
+    __publicField(this, "sortArray", this.options("sortArray"));
+    // zip with proper tuple typing
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/zip/
+    __publicField(this, "zip", this.options("zip"));
+    // ==========================================
+    // Comparison Operators
+    // ==========================================
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/cmp/
+    __publicField(this, "cmp", this.varargs("cmp"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/eq/
+    __publicField(this, "eq", this.varargs("eq"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/gt/
+    __publicField(this, "gt", this.varargs("gt"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/gte/
+    __publicField(this, "gte", this.varargs("gte"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/lt/
+    __publicField(this, "lt", this.varargs("lt"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/lte/
+    __publicField(this, "lte", this.varargs("lte"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/ne/
+    __publicField(this, "ne", this.varargs("ne"));
+    // Boolean operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/and/
+    __publicField(this, "and", this.varargs("and"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/or/
+    __publicField(this, "or", this.varargs("or"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/nor/
+    __publicField(this, "nor", this.varargs("nor"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/not/
+    __publicField(this, "not", this.id("not"));
+    // Conditional operators (fully typed from ExprBuilder)
+    /** Evaluates a boolean expression and returns one of two values.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/cond/ */
+    __publicField(this, "cond", this.options("cond"));
+    /** Returns the first non-null/non-missing expression (null coalescing).
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/ifNull/ */
+    __publicField(this, "ifNull", this.varargs("ifNull"));
+    /** Evaluates a series of case expressions, returning the value of the first match.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/switch/ */
+    __publicField(this, "switch", this.options("switch"));
+    // String operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/concat/
+    __publicField(this, "concat", this.varargs("concat"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/indexOfBytes/
+    __publicField(this, "indexOfBytes", (string, substring, start, end) => {
+      const args = [string, substring];
+      if (start !== void 0) args.push(start);
+      if (end !== void 0) args.push(end);
+      return this.varargs("indexOfBytes")(...args);
+    });
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/indexOfCP/
+    __publicField(this, "indexOfCP", (string, substring, start, end) => {
+      const args = [string, substring];
+      if (start !== void 0) args.push(start);
+      if (end !== void 0) args.push(end);
+      return this.varargs("indexOfCP")(...args);
+    });
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/ltrim/
+    __publicField(this, "ltrim", this.options("ltrim"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/regexFind/
+    __publicField(this, "regexFind", this.options("regexFind"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/regexFindAll/
+    __publicField(this, "regexFindAll", this.options("regexFindAll"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/regexMatch/
+    __publicField(this, "regexMatch", this.options("regexMatch"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/replaceAll/
+    __publicField(this, "replaceAll", this.options("replaceAll"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/replaceOne/
+    __publicField(this, "replaceOne", this.options("replaceOne"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/rtrim/
+    __publicField(this, "rtrim", this.options("rtrim"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/split/
+    __publicField(this, "split", this.varargs("split"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/strcasecmp/
+    __publicField(this, "strcasecmp", this.varargs("strcasecmp"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/strLenBytes/
+    __publicField(this, "strLenBytes", this.id("strLenBytes"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/strLenCP/
+    __publicField(this, "strLenCP", this.id("strLenCP"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/substr/
+    __publicField(this, "substr", this.varargs("substr"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/substrBytes/
+    __publicField(this, "substrBytes", this.varargs("substrBytes"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/substrCP/
+    __publicField(this, "substrCP", this.varargs("substrCP"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toLower/
+    __publicField(this, "toLower", this.id("toLower"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toUpper/
+    __publicField(this, "toUpper", this.id("toUpper"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/trim/
+    __publicField(this, "trim", this.options("trim"));
+    // Set operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/allElementsTrue/
+    __publicField(this, "allElementsTrue", this.id("allElementsTrue"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/anyElementTrue/
+    __publicField(this, "anyElementTrue", this.id("anyElementTrue"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setDifference/
+    __publicField(this, "setDifference", this.varargs("setDifference"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setEquals/
+    __publicField(this, "setEquals", this.varargs("setEquals"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setIntersection/
+    __publicField(this, "setIntersection", this.varargs("setIntersection"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setIsSubset/
+    __publicField(this, "setIsSubset", this.varargs("setIsSubset"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setUnion/
+    __publicField(this, "setUnion", this.varargs("setUnion"));
+    // Date operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateAdd/
+    __publicField(this, "dateAdd", this.options("dateAdd"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateDiff/
+    __publicField(this, "dateDiff", this.options("dateDiff"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateFromParts/
+    __publicField(this, "dateFromParts", this.options("dateFromParts"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateFromString/
+    __publicField(this, "dateFromString", this.options("dateFromString"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateSubtract/
+    __publicField(this, "dateSubtract", this.options("dateSubtract"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateToParts/
+    __publicField(this, "dateToParts", this.options("dateToParts"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateToString/
+    __publicField(this, "dateToString", this.options("dateToString"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dateTrunc/
+    __publicField(this, "dateTrunc", this.options("dateTrunc"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dayOfMonth/
+    __publicField(this, "dayOfMonth", this.id("dayOfMonth"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dayOfWeek/
+    __publicField(this, "dayOfWeek", this.id("dayOfWeek"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/dayOfYear/
+    __publicField(this, "dayOfYear", this.id("dayOfYear"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/hour/
+    __publicField(this, "hour", this.id("hour"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/isoDayOfWeek/
+    __publicField(this, "isoDayOfWeek", this.id("isoDayOfWeek"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/isoWeek/
+    __publicField(this, "isoWeek", this.id("isoWeek"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/isoWeekYear/
+    __publicField(this, "isoWeekYear", this.id("isoWeekYear"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/millisecond/
+    __publicField(this, "millisecond", this.id("millisecond"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/minute/
+    __publicField(this, "minute", this.id("minute"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/month/
+    __publicField(this, "month", this.id("month"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/second/
+    __publicField(this, "second", this.id("second"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/week/
+    __publicField(this, "week", this.id("week"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/year/
+    __publicField(this, "year", this.id("year"));
+    // Type conversion operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/convert/
+    __publicField(this, "convert", this.options("convert"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/isNumber/
+    __publicField(this, "isNumber", this.id("isNumber"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toBool/
+    __publicField(this, "toBool", this.id("toBool"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toDate/
+    __publicField(this, "toDate", this.id("toDate"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toDecimal/
+    __publicField(this, "toDecimal", this.id("toDecimal"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toDouble/
+    __publicField(this, "toDouble", this.id("toDouble"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toInt/
+    __publicField(this, "toInt", this.id("toInt"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toLong/
+    __publicField(this, "toLong", this.id("toLong"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toObjectId/
+    __publicField(this, "toObjectId", this.id("toObjectId"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toString/
+    __publicField(this, "toString", this.id("toString"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/type/
+    __publicField(this, "type", this.id("type"));
+    // Object operators (properly typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/getField/
+    __publicField(this, "getField", (options) => typeof options === "string" ? this.id("getField")(options) : this.options("getField")(options));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/mergeObjects/
+    __publicField(this, "mergeObjects", this.flexible("mergeObjects"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/setField/
+    __publicField(this, "setField", this.options("setField"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/unsetField/
+    __publicField(this, "unsetField", this.options("unsetField"));
+    // Variable operators (fully typed from ExprBuilder)
+    /** Binds variables for use within a scoped expression.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/let/ */
+    __publicField(this, "let", this.options("let"));
+    // Literal operator (fully typed from ExprBuilder)
+    /** Returns a value without parsing — prevents field path or operator interpretation.
+     * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/literal/ */
+    __publicField(this, "literal", this.id("literal"));
+    // Misc operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/meta/
+    __publicField(this, "meta", this.id("meta"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sampleRate/
+    __publicField(this, "sampleRate", this.id("sampleRate"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/binarySize/
+    __publicField(this, "binarySize", this.id("binarySize"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bsonSize/
+    __publicField(this, "bsonSize", this.id("bsonSize"));
+    // Bitwise operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bitAnd/
+    __publicField(this, "bitAnd", this.varargs("bitAnd"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bitOr/
+    __publicField(this, "bitOr", this.varargs("bitOr"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bitXor/
+    __publicField(this, "bitXor", this.varargs("bitXor"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bitNot/
+    __publicField(this, "bitNot", this.id("bitNot"));
+    // Trigonometric operators (fully typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sin/
+    __publicField(this, "sin", this.id("sin"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/cos/
+    __publicField(this, "cos", this.id("cos"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/tan/
+    __publicField(this, "tan", this.id("tan"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/asin/
+    __publicField(this, "asin", this.id("asin"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/acos/
+    __publicField(this, "acos", this.id("acos"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/atan/
+    __publicField(this, "atan", this.id("atan"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/atan2/
+    __publicField(this, "atan2", this.varargs("atan2"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/asinh/
+    __publicField(this, "asinh", this.id("asinh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/acosh/
+    __publicField(this, "acosh", this.id("acosh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/atanh/
+    __publicField(this, "atanh", this.id("atanh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sinh/
+    __publicField(this, "sinh", this.id("sinh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/cosh/
+    __publicField(this, "cosh", this.id("cosh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/tanh/
+    __publicField(this, "tanh", this.id("tanh"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/degreesToRadians/
+    __publicField(this, "degreesToRadians", this.id("degreesToRadians"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/radiansToDegrees/
+    __publicField(this, "radiansToDegrees", this.id("radiansToDegrees"));
+    // Dual-context operators (work as both expressions and accumulators)
+    // These use AccumulatorExprArg to reject bare strings — use "$field" not "field"
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/sum/
+    __publicField(this, "sum", this.flexible("sum"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/avg/
+    __publicField(this, "avg", this.flexible("avg"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/max/
+    __publicField(this, "max", this.flexible("max"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/min/
+    __publicField(this, "min", this.flexible("min"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/stdDevPop/
+    __publicField(this, "stdDevPop", this.flexible("stdDevPop"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/stdDevSamp/
+    __publicField(this, "stdDevSamp", this.flexible("stdDevSamp"));
+  }
+  // Helper to resolve nested callbacks and values
+  _resolve(value) {
+    const _foo = value;
+    if (_foo instanceof Ret) return this._resolve(_foo.__fn);
+    if (typeof _foo === "function") return this._resolve(_foo(this));
+    if (Array.isArray(_foo)) return _foo.map((item) => this._resolve(item));
+    if (_foo instanceof Date) return _foo;
+    if (_foo instanceof ObjectId) return _foo;
+    if (_foo instanceof RegExp) return _foo;
+    if (typeof _foo !== "object" || _foo === null) return _foo;
+    return Object.entries(_foo).reduce((acc, [k, v]) => ({ ...acc, [k]: this._resolve(v) }), {});
+  }
+};
+var ExprBuilder = class extends BaseBuilder {
+  constructor() {
+    super(...arguments);
+    /** Include this field in `$project` output (equivalent to `1`). */
+    __publicField(this, "include", 1);
+    /** Exclude this field from `$project` output (equivalent to `0`). */
+    __publicField(this, "exclude", 0);
+  }
+};
+var AccumulatorBuilder = class extends BaseBuilder {
+  constructor() {
+    super(...arguments);
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/addToSet/
+    __publicField(this, "addToSet", this.id("addToSet"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/count-accumulator/
+    __publicField(this, "count", this.options("count"));
+    // push with overloads for object literal vs single expression
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/push/
+    __publicField(this, "push", this.id("push"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottom/
+    __publicField(this, "bottom", this.options("bottom"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottomN/
+    __publicField(this, "bottomN", this.options("bottomN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/top/
+    __publicField(this, "top", this.options("top"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/topN/
+    __publicField(this, "topN", this.options("topN"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/accumulator/
+    __publicField(this, "accumulator", (options) => this.options("accumulator")(resolveAccumulator(options)));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/median/
+    __publicField(this, "median", this.options("median"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/percentile/
+    __publicField(this, "percentile", this.options("percentile"));
+  }
+};
+var WindowBuilder = class extends AccumulatorBuilder {
+  constructor() {
+    super(...arguments);
+    // Window-specific operators (properly typed from ExprBuilder)
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/denseRank/
+    __publicField(this, "denseRank", this.nullary("denseRank"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/covariancePop/
+    __publicField(this, "covariancePop", this.varargs("covariancePop"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/covarianceSamp/
+    __publicField(this, "covarianceSamp", this.varargs("covarianceSamp"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/derivative/
+    __publicField(this, "derivative", (options) => {
+      const resolved = this._resolve(options);
+      if ("window" in resolved) {
+        const { window, ...operatorArgs } = resolved;
+        return new Ret({ $derivative: operatorArgs, window });
+      }
+      return new Ret({ $derivative: resolved });
+    });
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/documentNumber/
+    __publicField(this, "documentNumber", this.nullary("documentNumber"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/expMovingAvg/
+    __publicField(this, "expMovingAvg", (options) => {
+      const resolved = this._resolve(options);
+      if ("window" in resolved) {
+        const { window, ...operatorArgs } = resolved;
+        return new Ret({ $expMovingAvg: operatorArgs, window });
+      }
+      return new Ret({ $expMovingAvg: resolved });
+    });
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/integral/
+    __publicField(this, "integral", (options) => {
+      const resolved = this._resolve(options);
+      if ("window" in resolved) {
+        const { window, ...operatorArgs } = resolved;
+        return new Ret({ $integral: operatorArgs, window });
+      }
+      return new Ret({ $integral: resolved });
+    });
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/linearFill/
+    __publicField(this, "linearFill", this.id("linearFill"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/locf/
+    __publicField(this, "locf", this.id("locf"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/percentRank/
+    __publicField(this, "percentRank", this.nullary("percentRank"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/rank/
+    __publicField(this, "rank", this.nullary("rank"));
+    // https://www.mongodb.com/docs/manual/reference/operator/aggregation/shift/
+    __publicField(this, "shift", this.options("shift"));
+  }
+};
+
+// src/migrate.ts
+var migrate = () => {
+  const pipe = (...stages) => {
+    const fakeAgg = {
+      _in: void 0,
+      _current: void 0,
+      stages: [],
+      pipe: void 0,
+      toList: void 0,
+      toMQL: void 0
+    };
+    const result = stages.reduce((agg, stage) => stage(agg), fakeAgg);
+    return {
+      __pipelineIn: void 0,
+      __pipelineOut: void 0,
+      stages: result.stages
+    };
+  };
+  return {
+    pipe
+  };
+};
+
+// src/runtime-utils.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+var unwrapRet = (value) => {
+  const _foo = value;
+  if (_foo instanceof Ret) return unwrapRet(_foo.__fn);
+  if (Array.isArray(_foo)) return _foo.map(unwrapRet);
+  if (_foo instanceof Date) return _foo;
+  if (_foo instanceof ObjectId2) return _foo;
+  if (_foo instanceof RegExp) return _foo;
+  if (typeof _foo !== "object" || _foo === null) return _foo;
+  return Object.entries(_foo).reduce((acc, [k, v]) => ({ ...acc, [k]: unwrapRet(v) }), {});
+};
+var resolveStage = (stage) => unwrapRet(typeof stage === "function" ? stage(new ExprBuilder()) : stage);
+var pushStage = (fn) => (options) => (agg) => ({ ...agg, stages: [...agg.stages ?? [], fn(options)] });
+
+// src/sluice-stages.ts
+var $addFields = pushStage((fieldsBuilder) => ({
+  $addFields: resolveStage(fieldsBuilder)
+}));
+var $bucket = pushStage((options) => {
+  const resolved = resolveStage(options);
+  if (resolved.output && typeof options.output === "function") {
+    resolved.output = resolveStage(options.output);
+  }
+  return { $bucket: resolved };
+});
+var $bucketAuto = pushStage((options) => ({
+  $bucketAuto: resolveStage(options)
+}));
+var $collStats = pushStage((options) => ({
+  $collStats: resolveStage(options)
+}));
+var $count = pushStage((field) => ({ $count: field }));
+var $densify = pushStage((options) => ({ $densify: resolveStage(options) }));
+var $documents = ((documents) => ({
+  stages: [{ $documents: documents }]
+}));
+var $facet = pushStage((pipelines) => {
+  const facetSpec = resolveStage(pipelines);
+  const transformedSpec = {};
+  for (const [key, val] of Object.entries(facetSpec)) {
+    if (val.stages) {
+      transformedSpec[key] = val.stages;
+    } else if (Array.isArray(val)) {
+      transformedSpec[key] = val;
+    } else {
+      transformedSpec[key] = val;
+    }
+  }
+  return { $facet: transformedSpec };
+});
+var $fill = pushStage((options) => ({ $fill: resolveStage(options) }));
+var $geoNear = pushStage((options) => ({ $geoNear: resolveStage(options) }));
+var $graphLookup = pushStage(
+  (options) => ({
+    $graphLookup: {
+      ...resolveStage(options),
+      from: options.from.__collectionName
+    }
+  })
+);
+var $group = pushStage((spec) => ({
+  $group: unwrapRet(typeof spec === "function" ? spec(new AccumulatorBuilder()) : spec)
+}));
+var $indexStats = pushStage(() => ({ $indexStats: {} }));
+var $limit = pushStage((n) => ({ $limit: n }));
+var $lookup = pushStage((options) => {
+  const spec = {
+    ...options,
+    from: options.from.__collectionName
+  };
+  if (typeof spec.pipeline === "function") {
+    spec.pipeline = resolveStage(spec.pipeline);
+  }
+  if (spec.pipeline && typeof spec.pipeline === "object" && "stages" in spec.pipeline) {
+    const pipeline = spec.pipeline;
+    if (typeof pipeline.stages !== "undefined") {
+      spec.pipeline = pipeline.stages;
+    }
+  }
+  return { $lookup: spec };
+});
+var $match = pushStage((filter) => ({ $match: resolveStage(filter) }));
+var $merge = pushStage((options) => ({
+  $merge: {
+    ...resolveStage(options),
+    into: options.into.__collectionName
+  }
+}));
+var $out = pushStage((options) => {
+  const resolved = resolveStage(options);
+  if ("coll" in resolved) {
+    return { $out: { db: resolved.db, coll: resolved.coll.__collectionName } };
+  }
+  return { $out: resolved.__collectionName };
+});
+var $project = pushStage((spec) => ({ $project: resolveStage(spec) }));
+var $redact = pushStage((expression) => ({
+  $redact: resolveStage(expression)
+}));
+var $replaceRoot = pushStage((options) => {
+  const resolved = resolveStage(options);
+  const spec = resolved !== null && typeof resolved === "object" && "newRoot" in resolved ? resolved : { newRoot: resolved };
+  return { $replaceRoot: spec };
+});
+var $replaceWith = pushStage((expression) => ({
+  $replaceWith: resolveStage(expression)
+}));
+var $sample = pushStage((options) => ({ $sample: resolveStage(options) }));
+var $set = pushStage((fields) => ({ $set: resolveStage(fields) }));
+var $setWindowFields = pushStage((options) => ({
+  $setWindowFields: unwrapRet(
+    typeof options === "function" ? options(new WindowBuilder()) : options
+  )
+}));
+var $skip = pushStage((n) => ({ $skip: n }));
+var $sort = pushStage((spec) => ({ $sort: resolveStage(spec) }));
+var $sortByCount = pushStage((expression) => ({
+  $sortByCount: resolveStage(expression)
+}));
+var $unionWith = pushStage((options) => {
+  const spec = {
+    ...options,
+    coll: options.coll.__collectionName
+  };
+  if (typeof spec.pipeline === "function") {
+    spec.pipeline = resolveStage(spec.pipeline);
+  }
+  if (spec.pipeline && typeof spec.pipeline === "object" && "stages" in spec.pipeline) {
+    const pipeline = spec.pipeline;
+    if (typeof pipeline.stages !== "undefined") {
+      spec.pipeline = pipeline.stages;
+    }
+  }
+  return { $unionWith: spec };
+});
+var $unset = ((...fields) => (agg) => ({
+  ...agg,
+  stages: [...agg.stages ?? [], { $unset: fields.length === 1 ? fields[0] : fields }]
+}));
+var $unwind = pushStage((pathOrOptions) => ({
+  $unwind: resolveStage(pathOrOptions)
+}));
+var $changeStream = pushStage((options) => ({
+  $changeStream: resolveStage(options)
+}));
+var $currentOp = pushStage((options) => ({
+  $currentOp: resolveStage(options)
+}));
+
+// src/crud/updates/stages/index.ts
+var update = () => {
+  const pipe = (...stages) => {
+    const fakeAgg = {
+      _in: void 0,
+      _current: void 0,
+      stages: [],
+      pipe: void 0,
+      toList: void 0,
+      toMQL: void 0
+    };
+    const result = stages.reduce((agg, stage) => stage(agg), fakeAgg);
+    return {
+      __pipelineIn: void 0,
+      __pipelineOut: void 0,
+      stages: result.stages
+    };
+  };
+  return {
+    set: $set,
+    unset: $unset,
+    replaceRoot: $replaceRoot,
+    replaceWith: $replaceWith,
+    addFields: $addFields,
+    project: $project,
+    pipe
+  };
+};
+
+// src/registry.ts
+function createCrudMethods(mongoCol) {
+  const extractFilter = (filterFn) => {
+    if (!filterFn) return {};
+    return filterFn({});
+  };
+  return {
+    find: ((filterFn, options) => ({
+      _filter: filterFn ? extractFilter(filterFn) : void 0,
+      _options: options,
+      toList: () => {
+        const filter = filterFn ? extractFilter(filterFn) : {};
+        let cursor = mongoCol.find(filter);
+        if (options?.sort) cursor = cursor.sort(options.sort);
+        if (options?.skip) cursor = cursor.skip(options.skip);
+        if (options?.limit) cursor = cursor.limit(options.limit);
+        if (options?.projection) cursor = cursor.project(options.projection);
+        if (options?.hint) cursor = cursor.hint(options.hint);
+        if (options?.maxTimeMS) cursor = cursor.maxTimeMS(options.maxTimeMS);
+        if (options?.collation) cursor = cursor.collation(options.collation);
+        if (options?.comment) cursor = cursor.comment(options.comment);
+        return cursor.toArray();
+      },
+      toOne: async () => {
+        const filter = filterFn ? extractFilter(filterFn) : {};
+        return mongoCol.findOne(
+          filter,
+          options
+        );
+      }
+    })),
+    findOne: ((filterFn, options) => ({
+      _filter: filterFn ? extractFilter(filterFn) : void 0,
+      _options: options,
+      toList: async () => {
+        const doc = await mongoCol.findOne(
+          filterFn ? extractFilter(filterFn) : {},
+          options
+        );
+        return doc ? [doc] : [];
+      },
+      toOne: () => mongoCol.findOne(
+        filterFn ? extractFilter(filterFn) : {},
+        options
+      )
+    })),
+    insertOne: (doc) => ({
+      _doc: doc,
+      execute: () => mongoCol.insertOne(doc)
+    }),
+    insertMany: (docs) => ({
+      _docs: docs,
+      execute: () => mongoCol.insertMany(docs)
+    }),
+    updateOne: ((filterFn, updateArg, options) => {
+      const filter = extractFilter(filterFn);
+      const updateDoc = typeof updateArg === "function" ? (
+        // Callback form: invoke with operators, get stages from TypedPipeline
+        updateArg(update()).stages
+      ) : updateArg;
+      return {
+        _filter: filter,
+        _update: updateDoc,
+        _options: options,
+        execute: () => mongoCol.updateOne(filter, updateDoc, options)
+      };
+    }),
+    updateMany: ((filterFn, updateArg, options) => {
+      const filter = extractFilter(filterFn);
+      const updateDoc = typeof updateArg === "function" ? (
+        // Callback form: invoke with operators, get stages from TypedPipeline
+        updateArg(update()).stages
+      ) : updateArg;
+      return {
+        _filter: filter,
+        _update: updateDoc,
+        _options: options,
+        execute: () => mongoCol.updateMany(filter, updateDoc, options)
+      };
+    }),
+    replaceOne: ((filterFn, replacement, options) => ({
+      _filter: extractFilter(filterFn),
+      _replacement: replacement,
+      _options: options,
+      execute: () => mongoCol.replaceOne(
+        extractFilter(filterFn),
+        replacement,
+        options
+      )
+    })),
+    deleteOne: ((filterFn) => ({
+      _filter: extractFilter(filterFn),
+      execute: () => mongoCol.deleteOne(extractFilter(filterFn))
+    })),
+    deleteMany: ((filterFn) => ({
+      _filter: extractFilter(filterFn),
+      execute: () => mongoCol.deleteMany(extractFilter(filterFn))
+    })),
+    findOneAndDelete: ((filterFn, options) => ({
+      _filter: extractFilter(filterFn),
+      execute: () => mongoCol.findOneAndDelete(extractFilter(filterFn), options).then((r) => r)
+    })),
+    findOneAndReplace: ((filterFn, replacement, options) => ({
+      _filter: extractFilter(filterFn),
+      _replacement: replacement,
+      execute: () => mongoCol.findOneAndReplace(
+        extractFilter(filterFn),
+        replacement,
+        options
+      ).then((r) => r)
+    })),
+    findOneAndUpdate: ((filterFn, updateArg, options) => ({
+      _filter: extractFilter(filterFn),
+      _update: updateArg,
+      execute: () => mongoCol.findOneAndUpdate(
+        extractFilter(filterFn),
+        updateArg,
+        options
+      ).then((r) => r)
+    })),
+    countDocuments: ((filterFn, options) => ({
+      execute: () => mongoCol.countDocuments(
+        filterFn ? extractFilter(filterFn) : {},
+        options
+      )
+    })),
+    estimatedDocumentCount: () => ({
+      execute: () => mongoCol.estimatedDocumentCount()
+    }),
+    distinct: ((field, filterFn) => ({
+      execute: () => mongoCol.distinct(field, filterFn ? extractFilter(filterFn) : {})
+    })),
+    bulkWrite: ((operations, options) => ({
+      _operations: operations,
+      execute: () => mongoCol.bulkWrite(operations, options)
+    }))
+  };
+}
+var collection = (name, _schema, mongoCol) => {
+  const col = {
+    __collectionName: name,
+    __collectionType: {}
+  };
+  const crud = createCrudMethods(mongoCol);
+  return Object.assign(col, {
+    aggregate: ((...stages) => {
+      let agg = { collectionName: name, stages: [] };
+      for (const s of stages) {
+        agg = s(agg);
+      }
+      return {
+        ...agg,
+        // eslint-disable-next-line custom/aggregate-must-tolist
+        toList: () => mongoCol.aggregate(agg.stages).toArray(),
+        toMQL: () => JSON.stringify(agg.stages, null, 2)
+      };
+    }),
+    ...crud
+  });
+};
+var registry = (version, schemas) => (client) => {
+  const bind = (name, schema) => collection(name, schema, client.collection(name));
+  return Object.fromEntries(
+    Object.entries(schemas).map(([name, schema]) => [name, bind(name, schema)])
+  );
+};
+export {
+  $addFields,
+  $bucket,
+  $bucketAuto,
+  $changeStream,
+  $collStats,
+  $count,
+  $currentOp,
+  $densify,
+  $documents,
+  $facet,
+  $fill,
+  $geoNear,
+  $graphLookup,
+  $group,
+  $indexStats,
+  $limit,
+  $lookup,
+  $match,
+  $merge,
+  $out,
+  $project,
+  $redact,
+  $replaceRoot,
+  $replaceWith,
+  $sample,
+  $set,
+  $setWindowFields,
+  $skip,
+  $sort,
+  $sortByCount,
+  $unionWith,
+  $unset,
+  $unwind,
+  AccumulatorBuilder,
+  ExprBuilder,
+  Ret,
+  WindowBuilder,
+  collection,
+  functionToString,
+  migrate,
+  registry,
+  resolveAccumulator
+};
+//# sourceMappingURL=index.js.map