axiodb 19.1.1 → 20.3.2

package/lib/Services/Aggregation/operators/expressionOperators.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNestedValue = getNestedValue;
 exports.setNestedValue = setNestedValue;
@@ -44,26 +43,27 @@ function evaluateExpression(doc, expr) {
     if (keys.length === 0)
         return {};
     const op = keys[0];
+    const exprObj = expr;
     switch (op) {
-        case "$add": return evaluateArithmetic(doc, expr.$add, (a, b) => a + b);
-        case "$subtract": return evaluateArithmetic(doc, expr.$subtract, (a, b) => a - b);
-        case "$multiply": return evaluateArithmetic(doc, expr.$multiply, (a, b) => a * b);
-        case "$divide": return evaluateArithmetic(doc, expr.$divide, (a, b) => a / b);
-        case "$mod": return evaluateArithmetic(doc, expr.$mod, (a, b) => a % b);
-        case "$abs": return Math.abs(evaluateExpression(doc, expr.$abs));
-        case "$ceil": return Math.ceil(evaluateExpression(doc, expr.$ceil));
-        case "$floor": return Math.floor(evaluateExpression(doc, expr.$floor));
-        case "$sqrt": return Math.sqrt(evaluateExpression(doc, expr.$sqrt));
+        case "$add": return evaluateArithmetic(doc, exprObj.$add, (a, b) => a + b);
+        case "$subtract": return evaluateArithmetic(doc, exprObj.$subtract, (a, b) => a - b);
+        case "$multiply": return evaluateArithmetic(doc, exprObj.$multiply, (a, b) => a * b);
+        case "$divide": return evaluateArithmetic(doc, exprObj.$divide, (a, b) => a / b);
+        case "$mod": return evaluateArithmetic(doc, exprObj.$mod, (a, b) => a % b);
+        case "$abs": return Math.abs(evaluateExpression(doc, exprObj.$abs));
+        case "$ceil": return Math.ceil(evaluateExpression(doc, exprObj.$ceil));
+        case "$floor": return Math.floor(evaluateExpression(doc, exprObj.$floor));
+        case "$sqrt": return Math.sqrt(evaluateExpression(doc, exprObj.$sqrt));
         case "$pow": {
-            const [base, exp] = expr.$pow.map((e) => evaluateExpression(doc, e));
+            const [base, exp] = exprObj.$pow.map((e) => evaluateExpression(doc, e));
             return Math.pow(base, exp);
         }
-        case "$log": return Math.log(evaluateExpression(doc, expr.$log));
-        case "$log10": return Math.log10(evaluateExpression(doc, expr.$log10));
-        case "$exp": return Math.exp(evaluateExpression(doc, expr.$exp));
-        case "$trunc": return Math.trunc(evaluateExpression(doc, expr.$trunc));
+        case "$log": return Math.log(evaluateExpression(doc, exprObj.$log));
+        case "$log10": return Math.log10(evaluateExpression(doc, exprObj.$log10));
+        case "$exp": return Math.exp(evaluateExpression(doc, exprObj.$exp));
+        case "$trunc": return Math.trunc(evaluateExpression(doc, exprObj.$trunc));
         case "$round": {
-            const roundArgs = expr.$round;
+            const roundArgs = exprObj.$round;
             if (Array.isArray(roundArgs)) {
                 const val = evaluateExpression(doc, roundArgs[0]);
                 const place = evaluateExpression(doc, roundArgs[1]) || 0;
@@ -73,24 +73,24 @@ function evaluateExpression(doc, expr) {
             return Math.round(evaluateExpression(doc, roundArgs));
         }
         case "$concat":
-            return expr.$concat.map(e => {
+            return exprObj.$concat.map(e => {
                 const v = evaluateExpression(doc, e);
                 return v === null || v === undefined ? "" : String(v);
             }).join("");
         case "$substr": {
-            const [str, start, len] = expr.$substr.map((e) => evaluateExpression(doc, e));
+            const [str, start, len] = exprObj.$substr.map((e) => evaluateExpression(doc, e));
             return String(str).substr(start, len);
         }
         case "$substrBytes": {
-            const [str, start, len] = expr.$substrBytes.map((e) => evaluateExpression(doc, e));
+            const [str, start, len] = exprObj.$substrBytes.map((e) => evaluateExpression(doc, e));
             return String(str).substr(start, len);
         }
-        case "$strLen": return String(evaluateExpression(doc, expr.$strLen)).length;
-        case "$strLenBytes": return Buffer.byteLength(String(evaluateExpression(doc, expr.$strLenBytes)));
-        case "$toLower": return String(evaluateExpression(doc, expr.$toLower)).toLowerCase();
-        case "$toUpper": return String(evaluateExpression(doc, expr.$toUpper)).toUpperCase();
+        case "$strLen": return String(evaluateExpression(doc, exprObj.$strLen)).length;
+        case "$strLenBytes": return Buffer.byteLength(String(evaluateExpression(doc, exprObj.$strLenBytes)));
+        case "$toLower": return String(evaluateExpression(doc, exprObj.$toLower)).toLowerCase();
+        case "$toUpper": return String(evaluateExpression(doc, exprObj.$toUpper)).toUpperCase();
         case "$trim": {
-            const trimInput = expr.$trim;
+            const trimInput = exprObj.$trim;
             if (typeof trimInput === "object" && trimInput.input) {
                 const str = String(evaluateExpression(doc, trimInput.input));
                 const chars = trimInput.chars ? evaluateExpression(doc, trimInput.chars) : undefined;
@@ -103,7 +103,7 @@ function evaluateExpression(doc, expr) {
             return String(evaluateExpression(doc, trimInput)).trim();
         }
         case "$ltrim": {
-            const ltrimInput = expr.$ltrim;
+            const ltrimInput = exprObj.$ltrim;
             if (typeof ltrimInput === "object" && ltrimInput.input) {
                 const str = String(evaluateExpression(doc, ltrimInput.input));
                 const chars = ltrimInput.chars ? evaluateExpression(doc, ltrimInput.chars) : undefined;
@@ -114,7 +114,7 @@ function evaluateExpression(doc, expr) {
             return String(evaluateExpression(doc, ltrimInput)).trimStart();
         }
         case "$rtrim": {
-            const rtrimInput = expr.$rtrim;
+            const rtrimInput = exprObj.$rtrim;
             if (typeof rtrimInput === "object" && rtrimInput.input) {
                 const str = String(evaluateExpression(doc, rtrimInput.input));
                 const chars = rtrimInput.chars ? evaluateExpression(doc, rtrimInput.chars) : undefined;
@@ -125,7 +125,7 @@ function evaluateExpression(doc, expr) {
             return String(evaluateExpression(doc, rtrimInput)).trimEnd();
         }
         case "$indexOfBytes": {
-            const args = expr.$indexOfBytes;
+            const args = exprObj.$indexOfBytes;
             const str = String(evaluateExpression(doc, args[0]));
             const search = String(evaluateExpression(doc, args[1]));
             const start = args[2] ? evaluateExpression(doc, args[2]) : 0;
@@ -133,76 +133,78 @@ function evaluateExpression(doc, expr) {
             return str.substring(start, end).indexOf(search) + (start > 0 ? start : 0);
         }
         case "$split": {
-            const [str, delim] = expr.$split.map((e) => evaluateExpression(doc, e));
+            const [str, delim] = exprObj.$split.map((e) => evaluateExpression(doc, e));
             return String(str).split(String(delim));
         }
         case "$replaceOne": {
-            const input = expr.$replaceOne;
+            const input = exprObj.$replaceOne;
             const str = String(evaluateExpression(doc, input.input));
             const find = String(evaluateExpression(doc, input.find));
             const replacement = String(evaluateExpression(doc, input.replacement));
             return str.replace(find, replacement);
         }
         case "$replaceAll": {
-            const input = expr.$replaceAll;
+            const input = exprObj.$replaceAll;
             const str = String(evaluateExpression(doc, input.input));
             const find = String(evaluateExpression(doc, input.find));
             const replacement = String(evaluateExpression(doc, input.replacement));
             return str.split(find).join(replacement);
         }
         case "$regexMatch": {
-            const input = expr.$regexMatch;
+            const input = exprObj.$regexMatch;
             const str = String(evaluateExpression(doc, input.input));
             const regex = new RegExp(input.regex, input.options || "");
             return regex.test(str);
         }
         case "$cmp": {
-            const [a, b] = expr.$cmp.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$cmp.map((e) => evaluateExpression(doc, e));
             return a === b ? 0 : a < b ? -1 : 1;
         }
         case "$eq": {
-            const [a, b] = expr.$eq.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$eq.map((e) => evaluateExpression(doc, e));
             return a === b;
         }
         case "$gt": {
-            const [a, b] = expr.$gt.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$gt.map((e) => evaluateExpression(doc, e));
             return a > b;
         }
         case "$gte": {
-            const [a, b] = expr.$gte.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$gte.map((e) => evaluateExpression(doc, e));
             return a >= b;
         }
         case "$lt": {
-            const [a, b] = expr.$lt.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$lt.map((e) => evaluateExpression(doc, e));
             return a < b;
         }
         case "$lte": {
-            const [a, b] = expr.$lte.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$lte.map((e) => evaluateExpression(doc, e));
             return a <= b;
         }
         case "$ne": {
-            const [a, b] = expr.$ne.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$ne.map((e) => evaluateExpression(doc, e));
             return a !== b;
         }
-        case "$and": return expr.$and.every(e => evaluateExpression(doc, e));
-        case "$or": return expr.$or.some(e => evaluateExpression(doc, e));
-        case "$not": return !evaluateExpression(doc, expr.$not[0]);
+        case "$and": return exprObj.$and.every(e => evaluateExpression(doc, e));
+        case "$or": return exprObj.$or.some(e => evaluateExpression(doc, e));
+        case "$not": return !evaluateExpression(doc, exprObj.$not[0]);
         case "$cond": {
-            if (Array.isArray(expr.$cond)) {
-                const [condition, thenVal, elseVal] = expr.$cond;
+            const condVal = exprObj.$cond;
+            if (Array.isArray(condVal)) {
+                const [condition, thenVal, elseVal] = condVal;
                 return evaluateExpression(doc, condition) ? evaluateExpression(doc, thenVal) : evaluateExpression(doc, elseVal);
             }
-            const { if: ifExpr, then: thenExpr, else: elseExpr } = expr.$cond;
+            const { if: ifExpr, then: thenExpr, else: elseExpr } = condVal;
             return evaluateExpression(doc, ifExpr) ? evaluateExpression(doc, thenExpr) : evaluateExpression(doc, elseExpr);
         }
         case "$ifNull": {
-            const [inputExpr, replacementExpr] = expr.$ifNull;
+            const [inputExpr, replacementExpr] = exprObj.$ifNull;
             const val = evaluateExpression(doc, inputExpr);
             return val === null || val === undefined ? evaluateExpression(doc, replacementExpr) : val;
         }
         case "$switch": {
-            const branches = expr.$switch.branches;
-            const defaultVal = expr.$switch.default;
+            const switchVal = exprObj.$switch;
+            const branches = switchVal.branches;
+            const defaultVal = switchVal.default;
             for (const branch of branches) {
                 if (evaluateExpression(doc, branch.case))
                     return evaluateExpression(doc, branch.then);
@@ -210,13 +212,14 @@ function evaluateExpression(doc, expr) {
             return defaultVal !== undefined ? evaluateExpression(doc, defaultVal) : undefined;
         }
         case "$arrayElemAt": {
-            const [arr, idx] = expr.$arrayElemAt.map((e) => evaluateExpression(doc, e));
+            const [arr, idx] = exprObj.$arrayElemAt.map((e) => evaluateExpression(doc, e));
             if (!Array.isArray(arr))
                 return undefined;
-            return arr[idx < 0 ? arr.length + idx : idx];
+            const idxNum = idx;
+            return arr[idxNum < 0 ? arr.length + idxNum : idxNum];
         }
         case "$arrayToObject": {
-            const arr = evaluateExpression(doc, expr.$arrayToObject);
+            const arr = evaluateExpression(doc, exprObj.$arrayToObject);
             if (!Array.isArray(arr))
                 return {};
             const result = {};
@@ -229,25 +232,25 @@ function evaluateExpression(doc, expr) {
             return result;
         }
         case "$concatArrays": {
-            const arrays = expr.$concatArrays.map((e) => evaluateExpression(doc, e));
+            const arrays = exprObj.$concatArrays.map((e) => evaluateExpression(doc, e));
             return arrays.flat();
         }
         case "$filter": {
-            const { input, as, cond } = expr.$filter;
+            const { input, as, cond } = exprObj.$filter;
             const arr = evaluateExpression(doc, input);
             if (!Array.isArray(arr))
                 return [];
             const varName = as || "this";
             return arr.filter(item => evaluateExpression(Object.assign(Object.assign({}, doc), { [varName]: item }), cond));
         }
-        case "$first": return evaluateExpression(doc, expr.$first);
-        case "$last": return evaluateExpression(doc, expr.$last);
+        case "$first": return evaluateExpression(doc, exprObj.$first);
+        case "$last": return evaluateExpression(doc, exprObj.$last);
         case "$size": {
-            const arr = evaluateExpression(doc, expr.$size);
+            const arr = evaluateExpression(doc, exprObj.$size);
             return Array.isArray(arr) ? arr.length : 0;
         }
         case "$slice": {
-            const args = expr.$slice;
+            const args = exprObj.$slice;
             const arr = evaluateExpression(doc, args[0]);
             if (!Array.isArray(arr))
                 return [];
@@ -257,7 +260,7 @@ function evaluateExpression(doc, expr) {
             return arr.slice(0, pos);
         }
         case "$map": {
-            const { input, as, in: inExpr } = expr.$map;
+            const { input, as, in: inExpr } = exprObj.$map;
             const arr = evaluateExpression(doc, input);
             if (!Array.isArray(arr))
                 return [];
@@ -265,17 +268,17 @@ function evaluateExpression(doc, expr) {
             return arr.map(item => evaluateExpression(Object.assign(Object.assign({}, doc), { [varName]: item }), inExpr));
         }
         case "$reduce": {
-            const { input, initialValue, in: inExpr } = expr.$reduce;
+            const { input, initialValue, in: inExpr } = exprObj.$reduce;
             const arr = evaluateExpression(doc, input);
             if (!Array.isArray(arr))
                 return evaluateExpression(doc, initialValue);
-            const varName = expr.$reduce.as || "this";
+            const varName = exprObj.$reduce.as || "this";
             return arr.reduce((acc, item) => {
                 return evaluateExpression(Object.assign(Object.assign({}, doc), { [varName]: item, value: acc }), inExpr);
             }, evaluateExpression(doc, initialValue));
         }
         case "$range": {
-            const args = expr.$range.map((e) => evaluateExpression(doc, e));
+            const args = exprObj.$range.map((e) => evaluateExpression(doc, e));
             const [start, end, step = 1] = args;
             const result = [];
             for (let i = start; i < end; i += step)
@@ -283,7 +286,7 @@ function evaluateExpression(doc, expr) {
             return result;
         }
         case "$zip": {
-            const { inputs, useLongestLength, defaults } = expr.$zip;
+            const { inputs, useLongestLength, defaults } = exprObj.$zip;
             const arrays = inputs.map((e) => evaluateExpression(doc, e));
             const maxLen = useLongestLength ? Math.max(...arrays.map((a) => a.length)) : Math.min(...arrays.map((a) => a.length));
             const result = [];
@@ -302,19 +305,19 @@ function evaluateExpression(doc, expr) {
             return result;
         }
         case "$in": {
-            const [needle, haystack] = expr.$in.map((e) => evaluateExpression(doc, e));
+            const [needle, haystack] = exprObj.$in.map((e) => evaluateExpression(doc, e));
             return Array.isArray(haystack) && haystack.includes(needle);
         }
         case "$indexOfArray": {
-            const [arr, searchValue] = expr.$indexOfArray.map((e) => evaluateExpression(doc, e));
+            const [arr, searchValue] = exprObj.$indexOfArray.map((e) => evaluateExpression(doc, e));
             return Array.isArray(arr) ? arr.indexOf(searchValue) : -1;
         }
         case "$reverseArray": {
-            const arr = evaluateExpression(doc, expr.$reverseArray);
+            const arr = evaluateExpression(doc, exprObj.$reverseArray);
             return Array.isArray(arr) ? [...arr].reverse() : [];
         }
         case "$sortArray": {
-            const { input, sortBy } = expr.$sortArray;
+            const { input, sortBy } = exprObj.$sortArray;
             const arr = evaluateExpression(doc, input);
             if (!Array.isArray(arr))
                 return [];
@@ -325,34 +328,34 @@ function evaluateExpression(doc, expr) {
                 sorted.sort((a, b) => (a > b ? -1 : a < b ? 1 : 0));
             return sorted;
         }
-        case "$year": return new Date(evaluateExpression(doc, expr.$year)).getFullYear();
-        case "$month": return new Date(evaluateExpression(doc, expr.$month)).getMonth() + 1;
-        case "$dayOfMonth": return new Date(evaluateExpression(doc, expr.$dayOfMonth)).getDate();
-        case "$hour": return new Date(evaluateExpression(doc, expr.$hour)).getHours();
-        case "$minute": return new Date(evaluateExpression(doc, expr.$minute)).getMinutes();
-        case "$second": return new Date(evaluateExpression(doc, expr.$second)).getSeconds();
-        case "$millisecond": return new Date(evaluateExpression(doc, expr.$millisecond)).getMilliseconds();
-        case "$dayOfWeek": return new Date(evaluateExpression(doc, expr.$dayOfWeek)).getDay() + 1;
+        case "$year": return new Date(evaluateExpression(doc, exprObj.$year)).getFullYear();
+        case "$month": return new Date(evaluateExpression(doc, exprObj.$month)).getMonth() + 1;
+        case "$dayOfMonth": return new Date(evaluateExpression(doc, exprObj.$dayOfMonth)).getDate();
+        case "$hour": return new Date(evaluateExpression(doc, exprObj.$hour)).getHours();
+        case "$minute": return new Date(evaluateExpression(doc, exprObj.$minute)).getMinutes();
+        case "$second": return new Date(evaluateExpression(doc, exprObj.$second)).getSeconds();
+        case "$millisecond": return new Date(evaluateExpression(doc, exprObj.$millisecond)).getMilliseconds();
+        case "$dayOfWeek": return new Date(evaluateExpression(doc, exprObj.$dayOfWeek)).getDay() + 1;
         case "$dayOfYear": {
-            const date = new Date(evaluateExpression(doc, expr.$dayOfYear));
+            const date = new Date(evaluateExpression(doc, exprObj.$dayOfYear));
             const start = new Date(date.getFullYear(), 0, 0);
             return Math.floor((date.getTime() - start.getTime()) / 86400000);
         }
-        case "$week": return getISOWeek(new Date(evaluateExpression(doc, expr.$week)));
+        case "$week": return getISOWeek(new Date(evaluateExpression(doc, exprObj.$week)));
         case "$isoDayOfWeek": {
-            const day = new Date(evaluateExpression(doc, expr.$isoDayOfWeek)).getDay();
+            const day = new Date(evaluateExpression(doc, exprObj.$isoDayOfWeek)).getDay();
             return day === 0 ? 7 : day;
         }
-        case "$isoWeekYear": return getISOWeekYear(new Date(evaluateExpression(doc, expr.$isoWeekYear)));
+        case "$isoWeekYear": return getISOWeekYear(new Date(evaluateExpression(doc, exprObj.$isoWeekYear)));
         case "$dateToString": {
-            const { format, date, onNull } = expr.$dateToString;
+            const { format, date, onNull } = exprObj.$dateToString;
             const d = evaluateExpression(doc, date);
             if (d === null || d === undefined)
                 return onNull || null;
             return formatDate(new Date(d), format || "%Y-%m-%dT%H:%M:%S.%LZ");
         }
         case "$dateFromString": {
-            const { dateString, onNull, onError } = expr.$dateFromString;
+            const { dateString, onNull, onError } = exprObj.$dateFromString;
             const str = evaluateExpression(doc, dateString);
             if (str === null || str === undefined)
                 return onNull || null;
@@ -364,20 +367,20 @@ function evaluateExpression(doc, expr) {
             }
         }
         case "$dateDiff": {
-            const { startDate, endDate, unit } = expr.$dateDiff;
+            const { startDate, endDate, unit } = exprObj.$dateDiff;
             return dateDiff(new Date(evaluateExpression(doc, startDate)), new Date(evaluateExpression(doc, endDate)), unit || "day");
         }
         case "$dateAdd": {
-            const { startDate, unit, amount } = expr.$dateAdd;
+            const { startDate, unit, amount } = exprObj.$dateAdd;
             return addToDate(new Date(evaluateExpression(doc, startDate)), unit || "day", evaluateExpression(doc, amount));
         }
         case "$dateSubtract": {
-            const { startDate, unit, amount } = expr.$dateSubtract;
+            const { startDate, unit, amount } = exprObj.$dateSubtract;
             return addToDate(new Date(evaluateExpression(doc, startDate)), unit || "day", -evaluateExpression(doc, amount));
         }
-        case "$toDate": return new Date(evaluateExpression(doc, expr.$toDate));
+        case "$toDate": return new Date(evaluateExpression(doc, exprObj.$toDate));
         case "$type": {
-            const val = evaluateExpression(doc, expr.$type);
+            const val = evaluateExpression(doc, exprObj.$type);
             if (val === null)
                 return "null";
             if (val === undefined)
@@ -391,7 +394,7 @@ function evaluateExpression(doc, expr) {
             return typeof val;
         }
         case "$convert": {
-            const { input, to, onError, onNull } = expr.$convert;
+            const { input, to, onError, onNull } = exprObj.$convert;
             const val = evaluateExpression(doc, input);
             if (val === null || val === undefined)
                 return onNull !== undefined ? onNull : null;
@@ -403,34 +406,34 @@ function evaluateExpression(doc, expr) {
             }
         }
         case "$toString": {
-            const val = evaluateExpression(doc, expr.$toString);
+            const val = evaluateExpression(doc, exprObj.$toString);
             return val !== null && val !== undefined ? String(val) : null;
         }
         case "$toInt": {
-            const val = evaluateExpression(doc, expr.$toInt);
+            const val = evaluateExpression(doc, exprObj.$toInt);
             return val !== null && val !== undefined ? parseInt(val, 10) : null;
         }
         case "$toLong": {
-            const val = evaluateExpression(doc, expr.$toLong);
+            const val = evaluateExpression(doc, exprObj.$toLong);
             return val !== null && val !== undefined ? parseInt(val, 10) : null;
         }
         case "$toDouble": {
-            const val = evaluateExpression(doc, expr.$toDouble);
+            const val = evaluateExpression(doc, exprObj.$toDouble);
             return val !== null && val !== undefined ? parseFloat(val) : null;
         }
         case "$toBool": {
-            const val = evaluateExpression(doc, expr.$toBool);
+            const val = evaluateExpression(doc, exprObj.$toBool);
             return val !== null && val !== undefined ? Boolean(val) : null;
         }
-        case "$toObjectId": return evaluateExpression(doc, expr.$toObjectId);
-        case "$toDecimal": return evaluateExpression(doc, expr.$toDecimal);
+        case "$toObjectId": return evaluateExpression(doc, exprObj.$toObjectId);
+        case "$toDecimal": return evaluateExpression(doc, exprObj.$toDecimal);
         case "$isNumber": {
-            const val = evaluateExpression(doc, expr.$isNumber);
+            const val = evaluateExpression(doc, exprObj.$isNumber);
             return typeof val === "number" && !isNaN(val);
         }
-        case "$isArray": return Array.isArray(evaluateExpression(doc, expr.$isArray));
+        case "$isArray": return Array.isArray(evaluateExpression(doc, exprObj.$isArray));
         case "$setEquals": {
-            const sets = expr.$setEquals.map((e) => evaluateExpression(doc, e));
+            const sets = exprObj.$setEquals.map((e) => evaluateExpression(doc, e));
             const [first, ...rest] = sets;
             const firstSet = new Set(first);
             return rest.every((arr) => {
@@ -439,43 +442,43 @@ function evaluateExpression(doc, expr) {
             });
         }
         case "$setIntersection": {
-            const sets = expr.$setIntersection.map((e) => evaluateExpression(doc, e));
+            const sets = exprObj.$setIntersection.map((e) => evaluateExpression(doc, e));
             return sets.reduce((a, b) => a.filter(v => b.includes(v)));
         }
         case "$setUnion": {
-            const sets = expr.$setUnion.map((e) => evaluateExpression(doc, e));
+            const sets = exprObj.$setUnion.map((e) => evaluateExpression(doc, e));
             return [...new Set(sets.flat())];
         }
         case "$setDifference": {
-            const [a, b] = expr.$setDifference.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$setDifference.map((e) => evaluateExpression(doc, e));
             return a.filter((v) => !b.includes(v));
         }
         case "$setIsSubset": {
-            const [a, b] = expr.$setIsSubset.map((e) => evaluateExpression(doc, e));
+            const [a, b] = exprObj.$setIsSubset.map((e) => evaluateExpression(doc, e));
             return a.every((v) => b.includes(v));
         }
         case "$anyElementTrue": {
-            const arr = evaluateExpression(doc, expr.$anyElementTrue);
+            const arr = evaluateExpression(doc, exprObj.$anyElementTrue);
             return Array.isArray(arr) && arr.some(v => Boolean(v));
         }
         case "$allElementsTrue": {
-            const arr = evaluateExpression(doc, expr.$allElementsTrue);
+            const arr = evaluateExpression(doc, exprObj.$allElementsTrue);
             return Array.isArray(arr) && arr.every(v => Boolean(v));
         }
-        case "$literal": return expr.$literal;
+        case "$literal": return exprObj.$literal;
         case "$getField": {
-            const { field, input } = expr.$getField;
+            const { field, input } = exprObj.$getField;
             const obj = input ? evaluateExpression(doc, input) : doc;
             return obj ? obj[field] : undefined;
         }
         case "$mergeObjects": {
-            const sources = Array.isArray(expr.$mergeObjects)
-                ? expr.$mergeObjects.map((e) => evaluateExpression(doc, e))
-                : [evaluateExpression(doc, expr.$mergeObjects)];
+            const sources = Array.isArray(exprObj.$mergeObjects)
+                ? exprObj.$mergeObjects.map((e) => evaluateExpression(doc, e))
+                : [evaluateExpression(doc, exprObj.$mergeObjects)];
             return Object.assign({}, ...sources.filter((s) => s !== null && typeof s === "object"));
         }
         case "$let": {
-            const { vars, in: inExpr } = expr.$let;
+            const { vars, in: inExpr } = exprObj.$let;
             const context = Object.assign({}, doc);
             for (const [varName, varExpr] of Object.entries(vars)) {
                 context[`$$${varName}`] = evaluateExpression(doc, varExpr);
@@ -486,7 +489,7 @@ function evaluateExpression(doc, expr) {
             const { OperatorRegistry } = require("../OperatorRegistry");
             const registered = OperatorRegistry.getOperator(op);
             if (registered && registered.type === "expression") {
-                return registered.fn(doc, expr[op]);
+                return registered.fn(doc, exprObj[op]);
             }
             return expr;
         }