@semics-tech/mongolite 1.0.0 → 1.2.0

package/dist/cjs/mongo-client.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoLite = void 0;
+const collection_js_1 = require("./collection.js");
+/**
+ * Core MongoLite client. Accepts any `IDatabaseAdapter` implementation.
+ *
+ * This class is intentionally free of `better-sqlite3` dependencies so that it
+ * can be bundled for Cloudflare Workers / Durable Objects. For Node.js use, prefer
+ * importing `MongoLite` from the package root, which adds convenient constructor
+ * overloads for file paths and options objects.
+ */
+class MongoLite {
+    constructor(adapter, options = {}) {
+        this.db = adapter;
+        this.options = options;
+    }
+    /**
+     * Connects to the database.
+     * For most custom adapters (e.g. Cloudflare) this is a no-op.
+     */
+    async connect() {
+        return this.db.connect();
+    }
+    /**
+     * Returns the underlying database adapter instance.
+     */
+    get database() {
+        return this.db;
+    }
+    /**
+     * Closes the database connection.
+     * For most custom adapters (e.g. Cloudflare) this is a no-op.
+     */
+    async close() {
+        return this.db.close();
+    }
+    /**
+     * Lists all collections (tables) in the database.
+     * @returns An object with a `toArray` method that resolves to an array of collection names.
+     */
+    listCollections() {
+        return {
+            toArray: async () => {
+                const result = await this.db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+                return result.map((row) => row.name);
+            },
+        };
+    }
+    /**
+     * Returns a typed collection handle.
+     * @param name The collection (table) name.
+     */
+    collection(name) {
+        return new collection_js_1.MongoLiteCollection(this.db, name, this.options);
+    }
+}
+exports.MongoLite = MongoLite;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/connection-registry.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Process-wide registry of open SQLite handles, keyed by connection identity.
+ *
+ * Consumers frequently end up with several `MongoLite` instances pointing at the
+ * same database file — a module-level client here, a background job there, each
+ * calling `new MongoLite(path)` independently. Every one of those opens its own
+ * SQLite connection, which turns same-process reads/writes into needless lock
+ * contention and forces each consumer to hand-roll its own instance cache.
+ *
+ * When `shared` is enabled, adapters acquire their underlying handle through this
+ * registry instead of opening one directly, so N adapter instances against the
+ * same identity share a single connection. Each adapter still tracks its own
+ * open/closed state; the handle is only really closed once the last holder
+ * releases it (reference counting), so one consumer calling `close()` can't pull
+ * the connection out from under another.
+ *
+ * Note this only dedupes connections *within a process*. Separate processes (e.g.
+ * worker threads spawned as child processes, or a job runner forking workers)
+ * each get their own registry and therefore their own connection — cross-process
+ * contention is handled by WAL mode and `busy_timeout`, not by sharing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionRegistry = exports.DEFAULT_BUSY_TIMEOUT_MS = void 0;
+exports.buildConnectionKey = buildConnectionKey;
+exports.isShareablePath = isShareablePath;
+/**
+ * Default `busy_timeout`, in milliseconds, applied to new connections.
+ *
+ * Lives here rather than in `db.ts` so the `node:sqlite` adapter can read it
+ * without importing that module — `db.ts` pulls in `better-sqlite3`, which is an
+ * optional dependency and may not be installed.
+ */
+exports.DEFAULT_BUSY_TIMEOUT_MS = 5000;
+class ConnectionRegistry {
+    constructor() {
+        this.entries = new Map();
+    }
+    /**
+     * Returns the handle registered for `key`, opening one via `open()` on first
+     * use. Increments the reference count for existing entries.
+     */
+    acquire(key, open) {
+        const existing = this.entries.get(key);
+        if (existing) {
+            existing.refCount++;
+            return existing.handle;
+        }
+        const handle = open();
+        this.entries.set(key, { handle, refCount: 1 });
+        return handle;
+    }
+    /**
+     * Drops one reference to `key`.
+     * @returns `true` when the caller held the last reference and is therefore
+     * responsible for closing the handle; `false` while other holders remain.
+     */
+    release(key, handle) {
+        const entry = this.entries.get(key);
+        // Untracked handle (never shared, or already fully released) — the caller
+        // owns it outright and should close it.
+        if (!entry || entry.handle !== handle) {
+            return true;
+        }
+        entry.refCount--;
+        if (entry.refCount > 0) {
+            return false;
+        }
+        this.entries.delete(key);
+        return true;
+    }
+    /** Live reference count for `key`; 0 when nothing holds it. */
+    refCount(key) {
+        return this.entries.get(key)?.refCount ?? 0;
+    }
+    /** Number of distinct shared handles currently open. */
+    get size() {
+        return this.entries.size;
+    }
+    /**
+     * Forgets every entry without closing the handles.
+     * Intended for test isolation, not for production teardown.
+     */
+    clear() {
+        this.entries.clear();
+    }
+}
+exports.ConnectionRegistry = ConnectionRegistry;
+/**
+ * Builds a stable registry key. Connections may only be shared when every
+ * setting that affects the handle's behaviour matches, so each of these is part
+ * of the identity rather than just the file path.
+ */
+function buildConnectionKey(parts) {
+    return JSON.stringify([
+        parts.backend,
+        parts.filePath,
+        parts.readOnly,
+        parts.WAL,
+        parts.busyTimeout,
+        parts.verbose,
+    ]);
+}
+/**
+ * Whether a database path is eligible for sharing.
+ *
+ * `:memory:` databases are private to their connection — two `:memory:` opens are
+ * two unrelated databases, so sharing them would silently merge state that
+ * callers expect to be isolated. Anonymous temp databases (empty path) behave the
+ * same way.
+ */
+function isShareablePath(filePath) {
+    const normalised = filePath.trim().toLowerCase();
+    if (normalised === '' || normalised === ':memory:') {
+        return false;
+    }
+    // file: URIs opt into sharing only when not explicitly in-memory.
+    if (normalised.startsWith('file:') && normalised.includes('mode=memory')) {
+        return false;
+    }
+    return true;
+}

package/dist/cjs/utils/indexing.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRawIndexColumns = extractRawIndexColumns;
+function extractRawIndexColumns(sql) {
+    const match = sql.match(/\(([\s\S]+)\)/); // allow multiline matching
+    if (!match)
+        return [];
+    const colsPart = match[1];
+    // Split on commas not inside parentheses
+    const columns = [];
+    let current = '';
+    let parens = 0;
+    for (let i = 0; i < colsPart.length; i++) {
+        const char = colsPart[i];
+        if (char === '(')
+            parens++;
+        if (char === ')')
+            parens--;
+        if (char === ',' && parens === 0) {
+            columns.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim())
+        columns.push(current.trim());
+    return columns.map((col) => {
+        // Extract direction (ASC or DESC)
+        const directionMatch = col.match(/\s+(ASC|DESC)\s*$/i);
+        const direction = directionMatch ? directionMatch[1].toUpperCase() : null;
+        // Remove direction from column string
+        const colWithoutDirection = directionMatch
+            ? col.slice(0, directionMatch.index).trim()
+            : col.trim();
+        // Check for json_extract and pull out path
+        const jsonMatch = colWithoutDirection.match(/json_extract\s*\(\s*[^,]+,\s*'([^']+)'\s*\)/i);
+        let column = jsonMatch
+            ? jsonMatch[1] // the JSON path like '$.age'
+            : colWithoutDirection; // fallback to raw column like testCol
+        column = column.replace('$.', ''); // Remove leading $ if present
+        return { column, direction };
+    });
+}

package/dist/cjs/utils/projection.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectionMode = resolveProjectionMode;
+exports.applyProjectionToDocument = applyProjectionToDocument;
+/**
+ * Determines whether a projection is an inclusion or exclusion projection, matching MongoDB's
+ * rule: any explicit non-`_id` inclusion (1/true) puts it in inclusion mode; otherwise any
+ * explicit non-`_id` exclusion (0/false) puts it in exclusion mode; with only `_id` specified
+ * (or nothing), `_id: 0`/`false` means exclusion, everything else defaults to inclusion.
+ */
+function resolveProjectionMode(projection) {
+    let hasExplicitInclusion = false;
+    let hasExplicitExclusion = false;
+    for (const key of Object.keys(projection)) {
+        if (key === '_id')
+            continue;
+        const value = projection[key];
+        if (value === 1 || value === true) {
+            hasExplicitInclusion = true;
+            break;
+        }
+        if (value === 0 || value === false) {
+            hasExplicitExclusion = true;
+        }
+    }
+    if (hasExplicitInclusion)
+        return 'include';
+    if (hasExplicitExclusion)
+        return 'exclude';
+    return projection._id === 0 || projection._id === false ? 'exclude' : 'include';
+}
+/**
+ * Applies a MongoDB-style projection to a single document, matching real MongoDB find()
+ * projection semantics: an empty/missing projection means no restriction, inclusion mode
+ * copies only listed fields (plus `_id` unless explicitly excluded), and exclusion mode copies
+ * everything except the listed fields. Supports dot-notation nested paths in both modes.
+ */
+function applyProjectionToDocument(doc, projection) {
+    if (!projection || Object.keys(projection).length === 0)
+        return doc;
+    const mode = resolveProjectionMode(projection);
+    const projectedDoc = {};
+    if (mode === 'include') {
+        for (const key in projection) {
+            const value = projection[key];
+            if (value !== 1 && value !== true)
+                continue;
+            if (key.includes('.')) {
+                const path = key.split('.');
+                let current = doc;
+                let target = projectedDoc;
+                for (let i = 0; i < path.length - 1; i++) {
+                    const segment = path[i];
+                    if (current[segment] === undefined || current[segment] === null)
+                        break;
+                    if (target[segment] === undefined) {
+                        target[segment] = {};
+                    }
+                    current = current[segment];
+                    target = target[segment];
+                }
+                const lastSegment = path[path.length - 1];
+                if (current && current[lastSegment] !== undefined) {
+                    target[lastSegment] = current[lastSegment];
+                }
+            }
+            else if (key in doc) {
+                projectedDoc[key] = doc[key];
+            }
+        }
+        if (projection._id !== 0 && projection._id !== false && '_id' in doc) {
+            projectedDoc._id = doc._id;
+        }
+    }
+    else {
+        Object.assign(projectedDoc, doc);
+        for (const key in projection) {
+            const value = projection[key];
+            if (value !== 0 && value !== false)
+                continue;
+            if (key.includes('.')) {
+                const path = key.split('.');
+                let current = projectedDoc;
+                for (let i = 0; i < path.length - 1; i++) {
+                    const segment = path[i];
+                    if (current[segment] === undefined)
+                        break;
+                    current = current[segment];
+                }
+                const lastSegment = path[path.length - 1];
+                if (current && current[lastSegment] !== undefined) {
+                    delete current[lastSegment];
+                }
+            }
+            else {
+                delete projectedDoc[key];
+            }
+        }
+    }
+    return projectedDoc;
+}

package/dist/cjs/utils/queryOperators.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_QUERY_OPERATORS = void 0;
+exports.evaluateOperator = evaluateOperator;
+exports.evaluateOperators = evaluateOperators;
+/**
+ * Shared query-operator registry used by in-memory ($match) filtering. Kept in sync with the
+ * operator set `buildComparisonCondition` (src/cursors/findCursor.ts) supports for SQL-generated
+ * find() filtering, so the two engines can't silently drift apart on what an operator means —
+ * see tests/operator-coverage.test.ts, which runs the same filter through both engines.
+ */
+exports.SUPPORTED_QUERY_OPERATORS = [
+    '$eq',
+    '$ne',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$in',
+    '$nin',
+    '$all',
+    '$exists',
+    '$not',
+    '$regex',
+    '$size',
+    '$type',
+    '$mod',
+];
+function matchesBsonType(value, bsonType) {
+    switch (bsonType) {
+        case 1:
+        case 'double':
+        case 'number':
+            return typeof value === 'number';
+        case 2:
+        case 'string':
+            return typeof value === 'string';
+        case 3:
+        case 'object':
+            return (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value) &&
+                !(value instanceof Date));
+        case 4:
+        case 'array':
+            return Array.isArray(value);
+        case 8:
+        case 'bool':
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 9:
+        case 'date':
+            return value instanceof Date;
+        case 10:
+        case 'null':
+            return value === null;
+        case 16:
+        case 'int':
+        case 18:
+        case 'long':
+            return typeof value === 'number' && Number.isInteger(value);
+        default:
+            return false;
+    }
+}
+/**
+ * Evaluates a single query operator against a document's field value. Used for in-memory
+ * filtering (e.g. aggregation `$match`) — the SQL-generating side (`buildComparisonCondition`)
+ * emits SQL fragments instead of booleans and stays separate, but should support the same
+ * operator set.
+ */
+function evaluateOperator(op, docValue, opValue, regexOptions) {
+    switch (op) {
+        case '$eq':
+            return JSON.stringify(docValue) === JSON.stringify(opValue);
+        case '$ne':
+            return JSON.stringify(docValue) !== JSON.stringify(opValue);
+        case '$gt':
+            return docValue > opValue;
+        case '$gte':
+            return docValue >= opValue;
+        case '$lt':
+            return docValue < opValue;
+        case '$lte':
+            return docValue <= opValue;
+        case '$in':
+            if (!Array.isArray(opValue))
+                return false;
+            if (Array.isArray(docValue)) {
+                return docValue.some((el) => opValue.some((v) => JSON.stringify(el) === JSON.stringify(v)));
+            }
+            return opValue.some((v) => JSON.stringify(v) === JSON.stringify(docValue));
+        case '$nin':
+            if (!Array.isArray(opValue))
+                return false;
+            if (Array.isArray(docValue)) {
+                return !docValue.some((el) => opValue.some((v) => JSON.stringify(el) === JSON.stringify(v)));
+            }
+            return !opValue.some((v) => JSON.stringify(v) === JSON.stringify(docValue));
+        case '$all':
+            if (!Array.isArray(opValue) || !Array.isArray(docValue))
+                return false;
+            return opValue.every((item) => docValue.some((el) => JSON.stringify(el) === JSON.stringify(item)));
+        case '$exists':
+            return opValue ? docValue !== undefined : docValue === undefined;
+        case '$not':
+            return !evaluateOperators(docValue, opValue);
+        case '$regex': {
+            const pattern = opValue instanceof RegExp
+                ? opValue
+                : new RegExp(opValue, typeof regexOptions === 'string' ? regexOptions : undefined);
+            return pattern.test(String(docValue));
+        }
+        case '$size':
+            return Array.isArray(docValue) && docValue.length === opValue;
+        case '$type': {
+            const types = Array.isArray(opValue) ? opValue : [opValue];
+            return types.some((t) => matchesBsonType(docValue, t));
+        }
+        case '$mod': {
+            if (!Array.isArray(opValue) || opValue.length !== 2 || typeof docValue !== 'number')
+                return false;
+            const [divisor, remainder] = opValue;
+            return Math.trunc(docValue) % divisor === remainder;
+        }
+        case '$options':
+            return true; // consumed alongside $regex, not an independent predicate
+        default:
+            return false; // unsupported operator — conservative: never matches, rather than silently no-op
+    }
+}
+/** Evaluates every operator in `ops` against `docValue`, ANDing the results together. */
+function evaluateOperators(docValue, ops) {
+    const regexOptions = ops['$options'];
+    for (const [op, opValue] of Object.entries(ops)) {
+        if (op === '$options')
+            continue;
+        if (!evaluateOperator(op, docValue, opValue, regexOptions))
+            return false;
+    }
+    return true;
+}

package/dist/collection.d.ts

@@ -151,6 +151,31 @@ export declare class MongoLiteCollection<T extends DocumentWithId> {
      * @returns {Promise<number>} The count of matching documents.
      */
     countDocuments(filter?: Filter<T>): Promise<number>;
+    /**
+     * Finds rows whose stored `data` column is not valid JSON.
+     *
+     * Filtered queries deliberately skip these rows — see
+     * `FindCursor.buildGuardedWhereClause` — so that one corrupted document can't
+     * make the whole collection unqueryable. That keeps reads working, but it also
+     * means such rows quietly stop appearing in results. This is the way to find
+     * them so they can be repaired or deleted (`deleteOne({ _id })` works on them,
+     * since `_id` lookups don't go through json1 functions).
+     *
+     * Intended for integrity checks and ops tooling rather than hot paths: it scans
+     * the table and returns the raw column text, not parsed documents.
+     *
+     * @returns The `_id` and raw stored text of every invalid row.
+     */
+    findInvalidJson(): Promise<{
+        _id: string;
+        data: string;
+    }[]>;
+    /**
+     * Counts rows whose stored `data` column is not valid JSON.
+     * Cheap enough to run on a schedule as a health check.
+     * @see findInvalidJson
+     */
+    countInvalidJson(): Promise<number>;
     /**
      * Returns the number of documents in the collection.
      * This is an estimate and may not reflect the exact count in concurrent environments.

package/dist/collection.js

@@ -349,7 +349,7 @@ export class MongoLiteCollection {
         await this.ensureTable();
         // Find the document first (only one)
         const paramsForSelect = [];
-        const whereClause = new FindCursor(this.db, this.name, filter)['buildWhereClause'](filter, paramsForSelect);
+        const whereClause = new FindCursor(this.db, this.name, filter)['buildGuardedWhereClause'](filter, paramsForSelect);
         const selectSql = `SELECT _id, data FROM "${this.name}" WHERE ${whereClause} LIMIT 1`;
         const rowToUpdate = await this.db.get(selectSql, paramsForSelect);
         if (!rowToUpdate && !options.upsert) {
@@ -478,7 +478,10 @@ export class MongoLiteCollection {
                         const value = opArgs[path];
                         const currentValue = this.getNestedValue(currentDoc, path);
                         const arr = Array.isArray(currentValue) ? currentValue : [];
-                        const items = typeof value === 'object' && value !== null && '$each' in value && Array.isArray(value.$each)
+                        const items = typeof value === 'object' &&
+                            value !== null &&
+                            '$each' in value &&
+                            Array.isArray(value.$each)
                             ? value.$each
                             : [value];
                         let changed = false;
@@ -614,7 +617,7 @@ export class MongoLiteCollection {
     async updateMany(filter, update) {
         await this.ensureTable();
         const paramsForSelect = [];
-        const whereClause = new FindCursor(this.db, this.name, filter)['buildWhereClause'](filter, paramsForSelect);
+        const whereClause = new FindCursor(this.db, this.name, filter)['buildGuardedWhereClause'](filter, paramsForSelect);
         const selectSql = `SELECT _id, data FROM "${this.name}" WHERE ${whereClause}`;
         const rowsToUpdate = await this.db.all(selectSql, paramsForSelect);
         if (rowsToUpdate.length === 0) {
@@ -712,7 +715,10 @@ export class MongoLiteCollection {
                             const value = opArgs[path];
                             const currentValue = this.getNestedValue(currentDoc, path);
                             const arr = Array.isArray(currentValue) ? currentValue : [];
-                            const items = typeof value === 'object' && value !== null && '$each' in value && Array.isArray(value.$each)
+                            const items = typeof value === 'object' &&
+                                value !== null &&
+                                '$each' in value &&
+                                Array.isArray(value.$each)
                                 ? value.$each
                                 : [value];
                             let changed = false;
@@ -1036,7 +1042,7 @@ export class MongoLiteCollection {
     async deleteOne(filter) {
         await this.ensureTable();
         const paramsForDelete = [];
-        const whereClause = new FindCursor(this.db, this.name, filter)['buildWhereClause'](filter, paramsForDelete);
+        const whereClause = new FindCursor(this.db, this.name, filter)['buildGuardedWhereClause'](filter, paramsForDelete);
         // Get the number of documents that would be deleted
         const countSql = `SELECT COUNT(*) as count FROM "${this.name}" WHERE ${whereClause} LIMIT 1`;
         const countResult = await this.db.get(countSql, paramsForDelete);
@@ -1065,7 +1071,7 @@ export class MongoLiteCollection {
     async deleteMany(filter) {
         await this.ensureTable();
         const paramsForDelete = [];
-        const whereClause = new FindCursor(this.db, this.name, filter)['buildWhereClause'](filter, paramsForDelete);
+        const whereClause = new FindCursor(this.db, this.name, filter)['buildGuardedWhereClause'](filter, paramsForDelete);
         // Get the number of documents that would be deleted
         const countSql = `SELECT COUNT(*) as count FROM "${this.name}" WHERE ${whereClause}`;
         const countResult = await this.db.get(countSql, paramsForDelete);
@@ -1091,11 +1097,40 @@ export class MongoLiteCollection {
     async countDocuments(filter = {}) {
         await this.ensureTable();
         const paramsForCount = [];
-        const whereClause = new FindCursor(this.db, this.name, filter)['buildWhereClause'](filter, paramsForCount);
+        const whereClause = new FindCursor(this.db, this.name, filter)['buildGuardedWhereClause'](filter, paramsForCount);
         const countSql = `SELECT COUNT(*) as count FROM "${this.name}" WHERE ${whereClause}`;
         const result = await this.db.get(countSql, paramsForCount);
         return result?.count || 0;
     }
+    /**
+     * Finds rows whose stored `data` column is not valid JSON.
+     *
+     * Filtered queries deliberately skip these rows — see
+     * `FindCursor.buildGuardedWhereClause` — so that one corrupted document can't
+     * make the whole collection unqueryable. That keeps reads working, but it also
+     * means such rows quietly stop appearing in results. This is the way to find
+     * them so they can be repaired or deleted (`deleteOne({ _id })` works on them,
+     * since `_id` lookups don't go through json1 functions).
+     *
+     * Intended for integrity checks and ops tooling rather than hot paths: it scans
+     * the table and returns the raw column text, not parsed documents.
+     *
+     * @returns The `_id` and raw stored text of every invalid row.
+     */
+    async findInvalidJson() {
+        await this.ensureTable();
+        return this.db.all(`SELECT _id, data FROM "${this.name}" WHERE json_valid(data) = 0`);
+    }
+    /**
+     * Counts rows whose stored `data` column is not valid JSON.
+     * Cheap enough to run on a schedule as a health check.
+     * @see findInvalidJson
+     */
+    async countInvalidJson() {
+        await this.ensureTable();
+        const result = await this.db.get(`SELECT COUNT(*) as count FROM "${this.name}" WHERE json_valid(data) = 0`);
+        return result?.count || 0;
+    }
     /**
      * Returns the number of documents in the collection.
      * This is an estimate and may not reflect the exact count in concurrent environments.
@@ -1124,9 +1159,7 @@ export class MongoLiteCollection {
             return null;
         }
         // Update by _id when available to ensure we modify the exact document we found
-        const updateFilter = existingId !== undefined && existingId !== null
-            ? { _id: existingId }
-            : filter;
+        const updateFilter = existingId !== undefined && existingId !== null ? { _id: existingId } : filter;
         const updateResult = await this.updateOne(updateFilter, update, { upsert });
         if (returnDocument === 'after') {
             const targetId = updateResult.upsertedId ?? existingId;
@@ -1487,7 +1520,8 @@ export class MongoLiteCollection {
                                 const nums = groupDocs
                                     .map((doc) => this.getNestedValue(doc, fieldName))
                                     .filter((v) => typeof v === 'number');
-                                groupResult[field] = nums.length > 0 ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                                groupResult[field] =
+                                    nums.length > 0 ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
                             }
                             break;
                         }
@@ -1497,7 +1531,8 @@ export class MongoLiteCollection {
                                 const vals = groupDocs
                                     .map((doc) => this.getNestedValue(doc, fieldName))
                                     .filter((v) => v !== undefined && v !== null);
-                                groupResult[field] = vals.length > 0 ? vals.reduce((a, b) => (a < b ? a : b)) : null;
+                                groupResult[field] =
+                                    vals.length > 0 ? vals.reduce((a, b) => (a < b ? a : b)) : null;
                             }
                             break;
                         }
@@ -1507,7 +1542,8 @@ export class MongoLiteCollection {
                                 const vals = groupDocs
                                     .map((doc) => this.getNestedValue(doc, fieldName))
                                     .filter((v) => v !== undefined && v !== null);
-                                groupResult[field] = vals.length > 0 ? vals.reduce((a, b) => (a > b ? a : b)) : null;
+                                groupResult[field] =
+                                    vals.length > 0 ? vals.reduce((a, b) => (a > b ? a : b)) : null;
                             }
                             break;
                         }
@@ -1603,7 +1639,10 @@ export class MongoLiteCollection {
             if (key.startsWith('$'))
                 continue;
             const docValue = this.getNestedValue(doc, key);
-            if (typeof value === 'object' && value !== null && !(value instanceof RegExp) && !(value instanceof Date)) {
+            if (typeof value === 'object' &&
+                value !== null &&
+                !(value instanceof RegExp) &&
+                !(value instanceof Date)) {
                 const ops = value;
                 const hasOps = Object.keys(ops).some((k) => k.startsWith('$'));
                 if (hasOps) {