@semics-tech/mongolite 1.4.0 → 1.4.2

package/dist/cjs/cursors/findCursor.js

@@ -123,15 +123,16 @@ function restoreDates(obj) {
  * Represents a cursor for find operations, allowing chaining of limit, skip, and sort.
  */
 class FindCursor {
-    constructor(db, collectionName, initialFilter, options = {}) {
+    constructor(db, collectionName, filter, options = {}) {
         this.db = db;
         this.collectionName = collectionName;
+        this.filter = filter;
         this.options = options;
         this.limitCount = null;
         this.skipCount = null;
         this.sortCriteria = null;
         this.projectionFields = null;
-        this.queryParts = this.buildSelectQuery(initialFilter);
+        this.queryParts = this.buildSelectQuery(filter);
     }
     parseJsonPath(path) {
         return `'$.${path.replace(/\./g, '.')}'`;
@@ -494,7 +495,14 @@ class FindCursor {
         SELECT 1 
         FROM json_each(${eachArg}) as array_elements 
         WHERE `;
-            if (typeof value === 'object' && value !== null) {
+            const valueKeys = typeof value === 'object' && value !== null && !Array.isArray(value)
+                ? Object.keys(value)
+                : [];
+            if (valueKeys.length > 0 && valueKeys.every((k) => k.startsWith('$') && k !== '$and')) {
+                // Scalar-element form: { $elemMatch: { $gt: 5, $lt: 10 } } / { $eq: 'x' }
+                elemMatchSubquery += this.buildScalarElemMatchConditions(value, params);
+            }
+            else if (typeof value === 'object' && value !== null) {
                 const conditions = this.buildObjectConditions(value, params, 'array_elements');
                 elemMatchSubquery += conditions;
             }
@@ -508,6 +516,50 @@ class FindCursor {
         }
         return '1=0'; // Unsupported array operator
     }
+    /**
+     * Builds conditions for $elemMatch applied to arrays of scalars, where each operator
+     * applies to the array element itself (`array_elements.value`).
+     */
+    buildScalarElemMatchConditions(ops, params) {
+        const col = 'array_elements.value';
+        const parts = [];
+        for (const [op, v] of Object.entries(ops)) {
+            switch (op) {
+                case '$eq':
+                    params.push(toSQLiteValue(v));
+                    parts.push(`${col} = ?`);
+                    break;
+                case '$ne':
+                    params.push(toSQLiteValue(v));
+                    parts.push(`${col} <> ?`);
+                    break;
+                case '$gt':
+                case '$gte':
+                case '$lt':
+                case '$lte': {
+                    const sqlOp = { $gt: '>', $gte: '>=', $lt: '<', $lte: '<=' }[op];
+                    params.push(toSQLiteValue(v));
+                    parts.push(`${col} ${sqlOp} ?`);
+                    break;
+                }
+                case '$in':
+                case '$nin': {
+                    const list = Array.isArray(v) ? v : [];
+                    if (list.length === 0) {
+                        parts.push(op === '$in' ? '1=0' : '1=1');
+                    }
+                    else {
+                        params.push(...list.map((x) => toSQLiteValue(x)));
+                        parts.push(`${col} ${op === '$in' ? 'IN' : 'NOT IN'} (${list.map(() => '?').join(',')})`);
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported operator ${op} inside $elemMatch on scalar array elements`);
+            }
+        }
+        return parts.join(' AND ');
+    }
     /**
      * Builds conditions for an object with potentially nested operators
      */
@@ -840,9 +892,10 @@ class FindCursor {
      * @returns A promise that resolves to the count of matching documents.
      */
     async count() {
-        const whereClause = this.buildWhereClause({}, []);
+        const params = [];
+        const whereClause = this.buildGuardedWhereClause(this.filter, params);
         const countSql = `SELECT COUNT(*) as count FROM "${this.collectionName}" WHERE ${whereClause}`;
-        const result = await this.db.get(countSql);
+        const result = await this.db.get(countSql, params);
         return result?.count ?? 0; // Return 0 if result is undefined
     }
 }

package/dist/cjs/utils/aggregation.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * In-memory aggregation expression evaluation, shared by $addFields, $project, $group,
+ * $replaceRoot and $match/$expr.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_ACCUMULATORS = exports.SUPPORTED_STAGES = void 0;
+exports.getPath = getPath;
+exports.isOperatorExpression = isOperatorExpression;
+exports.evaluateExpression = evaluateExpression;
+exports.evaluateExprFilter = evaluateExprFilter;
+exports.filterUsesExpr = filterUsesExpr;
+/** Safely reads a dotted path from a value. Returns undefined when any segment is missing. */
+function getPath(obj, path) {
+    let current = obj;
+    for (const key of path.split('.')) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (Array.isArray(current)) {
+            if (/^\d+$/.test(key)) {
+                current = current[Number(key)];
+                continue;
+            }
+            // Mongo maps the remaining path over array elements
+            return current.map((el) => getPath(el, key)).filter((v) => v !== undefined);
+        }
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Date);
+}
+/** True if `v` is an expression operator object such as `{ $add: [...] }`. */
+function isOperatorExpression(v) {
+    if (!isPlainObject(v))
+        return false;
+    const keys = Object.keys(v);
+    return keys.length === 1 && keys[0].startsWith('$');
+}
+function eq(a, b) {
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function cmp(a, b) {
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() - b.getTime();
+    const x = a;
+    const y = b;
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+function truthy(v) {
+    return !(v === false || v === null || v === undefined || v === 0);
+}
+function num(v) {
+    return typeof v === 'number' ? v : null;
+}
+/**
+ * Evaluates an aggregation expression against a document.
+ * Supports field paths ("$a.b"), $$ROOT/$$CURRENT, literals, arrays, nested objects and a
+ * common subset of operators. Unsupported operators throw.
+ */
+function evaluateExpression(doc, expr) {
+    if (typeof expr === 'string') {
+        if (expr === '$$ROOT' || expr === '$$CURRENT')
+            return doc;
+        if (expr.startsWith('$$'))
+            throw new Error(`Unsupported aggregation variable: ${expr}`);
+        if (expr.startsWith('$'))
+            return getPath(doc, expr.slice(1));
+        return expr;
+    }
+    if (Array.isArray(expr))
+        return expr.map((e) => evaluateExpression(doc, e));
+    if (expr instanceof Date || !isPlainObject(expr))
+        return expr;
+    const keys = Object.keys(expr);
+    if (keys.length === 1 && keys[0].startsWith('$')) {
+        return evaluateOperator(doc, keys[0], expr[keys[0]]);
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(expr)) {
+        if (k.startsWith('$')) {
+            throw new Error(`An object representing an expression must have exactly one field: ${k}`);
+        }
+        const val = evaluateExpression(doc, v);
+        if (val !== undefined)
+            out[k] = val;
+    }
+    return out;
+}
+function args(doc, raw) {
+    return (Array.isArray(raw) ? raw : [raw]).map((a) => evaluateExpression(doc, a));
+}
+function evaluateOperator(doc, op, raw) {
+    switch (op) {
+        case '$literal':
+            return raw;
+        case '$add': {
+            const vals = args(doc, raw);
+            if (vals.some((v) => v === null || v === undefined))
+                return null;
+            if (vals.some((v) => v instanceof Date)) {
+                return new Date(vals.reduce((s, v) => s + (v instanceof Date ? v.getTime() : v), 0));
+            }
+            return vals.reduce((s, v) => s + v, 0);
+        }
+        case '$subtract': {
+            const [a, b] = args(doc, raw);
+            if (a === null || a === undefined || b === null || b === undefined)
+                return null;
+            if (a instanceof Date && b instanceof Date)
+                return a.getTime() - b.getTime();
+            if (a instanceof Date)
+                return new Date(a.getTime() - b);
+            return a - b;
+        }
+        case '$multiply': {
+            const vals = args(doc, raw);
+            if (vals.some((v) => num(v) === null))
+                return null;
+            return vals.reduce((s, v) => s * v, 1);
+        }
+        case '$divide': {
+            const [a, b] = args(doc, raw);
+            if (num(a) === null || num(b) === null)
+                return null;
+            return a / b;
+        }
+        case '$mod': {
+            const [a, b] = args(doc, raw);
+            if (num(a) === null || num(b) === null)
+                return null;
+            return a % b;
+        }
+        case '$concat': {
+            const vals = args(doc, raw);
+            if (vals.some((v) => v === null || v === undefined))
+                return null;
+            return vals.join('');
+        }
+        case '$toUpper': {
+            const [v] = args(doc, raw);
+            return v === null || v === undefined ? '' : String(v).toUpperCase();
+        }
+        case '$toLower': {
+            const [v] = args(doc, raw);
+            return v === null || v === undefined ? '' : String(v).toLowerCase();
+        }
+        case '$eq': {
+            const [a, b] = args(doc, raw);
+            return eq(a, b);
+        }
+        case '$ne': {
+            const [a, b] = args(doc, raw);
+            return !eq(a, b);
+        }
+        case '$gt': {
+            const [a, b] = args(doc, raw);
+            return cmp(a, b) > 0;
+        }
+        case '$gte': {
+            const [a, b] = args(doc, raw);
+            return cmp(a, b) >= 0;
+        }
+        case '$lt': {
+            const [a, b] = args(doc, raw);
+            return cmp(a, b) < 0;
+        }
+        case '$lte': {
+            const [a, b] = args(doc, raw);
+            return cmp(a, b) <= 0;
+        }
+        case '$and':
+            return (Array.isArray(raw) ? raw : [raw]).every((e) => truthy(evaluateExpression(doc, e)));
+        case '$or':
+            return (Array.isArray(raw) ? raw : [raw]).some((e) => truthy(evaluateExpression(doc, e)));
+        case '$not': {
+            const [v] = args(doc, raw);
+            return !truthy(v);
+        }
+        case '$cond': {
+            let cond, thenE, elseE;
+            if (Array.isArray(raw))
+                [cond, thenE, elseE] = raw;
+            else {
+                const o = raw;
+                cond = o['if'];
+                thenE = o['then'];
+                elseE = o['else'];
+            }
+            return evaluateExpression(doc, truthy(evaluateExpression(doc, cond)) ? thenE : elseE);
+        }
+        case '$ifNull': {
+            const vals = Array.isArray(raw) ? raw : [raw];
+            for (let i = 0; i < vals.length - 1; i++) {
+                const v = evaluateExpression(doc, vals[i]);
+                if (v !== null && v !== undefined)
+                    return v;
+            }
+            return evaluateExpression(doc, vals[vals.length - 1]);
+        }
+        case '$size': {
+            const [v] = args(doc, raw);
+            if (!Array.isArray(v))
+                throw new Error('The argument to $size must be an array');
+            return v.length;
+        }
+        case '$arrayElemAt': {
+            const [arr, idx] = args(doc, raw);
+            if (!Array.isArray(arr) || typeof idx !== 'number')
+                return null;
+            const i = idx < 0 ? arr.length + idx : idx;
+            return arr[i];
+        }
+        case '$first': {
+            const [arr] = args(doc, raw);
+            return Array.isArray(arr) ? arr[0] : null;
+        }
+        case '$last': {
+            const [arr] = args(doc, raw);
+            return Array.isArray(arr) ? arr[arr.length - 1] : null;
+        }
+        default:
+            throw new Error(`Unsupported aggregation expression operator: ${op}`);
+    }
+}
+/** Evaluates a $match `$expr` value to a boolean. */
+function evaluateExprFilter(doc, expr) {
+    return truthy(evaluateExpression(doc, expr));
+}
+/** True if a $match filter uses $expr anywhere in its logical tree. */
+function filterUsesExpr(filter) {
+    if (!isPlainObject(filter))
+        return false;
+    for (const [k, v] of Object.entries(filter)) {
+        if (k === '$expr')
+            return true;
+        if ((k === '$and' || k === '$or' || k === '$nor') && Array.isArray(v) && v.some(filterUsesExpr))
+            return true;
+    }
+    return false;
+}
+exports.SUPPORTED_STAGES = [
+    '$match',
+    '$project',
+    '$addFields',
+    '$set',
+    '$sort',
+    '$limit',
+    '$skip',
+    '$count',
+    '$group',
+    '$unwind',
+    '$lookup',
+    '$replaceRoot',
+    '$replaceWith',
+];
+exports.SUPPORTED_ACCUMULATORS = [
+    '$sum',
+    '$avg',
+    '$min',
+    '$max',
+    '$push',
+    '$addToSet',
+    '$first',
+    '$last',
+    '$count',
+];

package/dist/cjs/utils/queryOperators.js

@@ -25,6 +25,7 @@ exports.SUPPORTED_QUERY_OPERATORS = [
     '$size',
     '$type',
     '$mod',
+    '$elemMatch',
 ];
 function matchesBsonType(value, bsonType) {
     switch (bsonType) {
@@ -123,6 +124,14 @@ function evaluateOperator(op, docValue, opValue, regexOptions) {
             const [divisor, remainder] = opValue;
             return Math.trunc(docValue) % divisor === remainder;
         }
+        case '$elemMatch': {
+            if (!Array.isArray(docValue) || typeof opValue !== 'object' || opValue === null)
+                return false;
+            const spec = opValue;
+            const keys = Object.keys(spec);
+            const scalarForm = keys.length > 0 && keys.every((k) => k.startsWith('$') && !LOGICAL.has(k));
+            return docValue.some((el) => scalarForm ? evaluateOperators(el, spec) : matchesElementFilter(el, spec));
+        }
         case '$options':
             return true; // consumed alongside $regex, not an independent predicate
         default:
@@ -140,3 +149,43 @@ function evaluateOperators(docValue, ops) {
     }
     return true;
 }
+const LOGICAL = new Set(['$and', '$or', '$nor']);
+function getPathValue(obj, path) {
+    let cur = obj;
+    for (const k of path.split('.')) {
+        if (cur === null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[k];
+    }
+    return cur;
+}
+/** Matches one array element (an object) against an $elemMatch sub-filter. */
+function matchesElementFilter(el, filter) {
+    for (const [key, cond] of Object.entries(filter)) {
+        if ((key === '$and' || key === '$or' || key === '$nor') && Array.isArray(cond)) {
+            const results = cond.map((f) => matchesElementFilter(el, f));
+            if (key === '$and' && !results.every(Boolean))
+                return false;
+            if (key === '$or' && !results.some(Boolean))
+                return false;
+            if (key === '$nor' && results.some(Boolean))
+                return false;
+            continue;
+        }
+        const v = getPathValue(el, key);
+        const isOps = typeof cond === 'object' &&
+            cond !== null &&
+            !(cond instanceof RegExp) &&
+            !(cond instanceof Date) &&
+            !Array.isArray(cond) &&
+            Object.keys(cond).some((k) => k.startsWith('$'));
+        if (isOps) {
+            if (!evaluateOperators(v, cond))
+                return false;
+        }
+        else if (JSON.stringify(v) !== JSON.stringify(cond)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/collection.d.ts

@@ -227,7 +227,10 @@ export declare class MongoLiteCollection<T extends DocumentWithId> {
     drop(): Promise<void>;
     /**
      * Executes an aggregation pipeline on the collection.
-     * Supports: $match, $project, $sort, $limit, $skip, $count, $group, $unwind, $addFields.
+     * Supports: $match (incl. $expr), $project, $sort, $limit, $skip, $count, $group
+     * ($sum, $avg, $min, $max, $push, $addToSet, $first, $last, $count), $unwind, $addFields/$set,
+     * $replaceRoot/$replaceWith and $lookup (equality form, local collections).
+     * Unknown stages and accumulators throw.
      * @param pipeline An array of pipeline stage documents.
      * @returns An object with a toArray() method that returns the aggregation result.
      */
@@ -244,6 +247,11 @@ export declare class MongoLiteCollection<T extends DocumentWithId> {
      * @private
      */
     private applyGroupStage;
+    /**
+     * Applies a $lookup stage (equality match against another collection in the same database).
+     * @private
+     */
+    private applyLookupStage;
     /**
      * Applies a $project stage to a document.
      * @private