@semics-tech/mongolite 1.0.0 → 1.1.0

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/index.d.ts

@@ -1,4 +1,4 @@
-import { IDatabaseAdapter, MongoLiteOptions as DBMongoLiteOptions } from './db.js';
+import type { IDatabaseAdapter, MongoLiteOptions as DBMongoLiteOptions } from './db.js';
 import { MongoLite as MongoLiteBase, MongoLiteBaseOptions } from './mongo-client.js';
 export { MongoLiteCollection } from './collection.js';
 export * from './types.js';
@@ -9,13 +9,16 @@ export { CloudflareDurableObjectAdapter, } from './adapters/cloudflare.js';
 export type { SqlStorage, SqlStorageCursor, SqlStorageValue, } from './adapters/cloudflare.js';
 export { BrowserSqliteAdapter } from './adapters/browser.js';
 export type { SqlJsDatabase, SqlJsStatement } from './adapters/browser.js';
+export { NodeSqliteAdapter } from './adapters/node-sqlite.js';
 export interface MongoLiteClientOptions extends DBMongoLiteOptions {
 }
 /**
  * MongoLite class is the main entry point for interacting with the SQLite-backed database.
  *
  * You can construct it with:
- * - A file path string — uses the built-in `better-sqlite3` adapter.
+ * - A file path string — uses the built-in `node:sqlite` adapter (`NodeSqliteAdapter`).
+ *   Requires Node.js 22.5.0+; for older runtimes, import `MongoLite` from
+ *   `@semics-tech/mongolite/better-sqlite3` instead.
  * - A `MongoLiteClientOptions` object — uses the built-in adapter with options.
  * - An `IDatabaseAdapter` instance — use a custom adapter such as
  *   `CloudflareDurableObjectAdapter` for Cloudflare Durable Objects.

package/dist/index.js

@@ -1,15 +1,18 @@
-import { SQLiteDB } from './db.js';
+import { NodeSqliteAdapter } from './adapters/node-sqlite.js';
 import { MongoLite as MongoLiteBase } from './mongo-client.js';
 export { MongoLiteCollection } from './collection.js';
 export * from './types.js';
 export { ChangeStream } from './changeStream.js';
 export { CloudflareDurableObjectAdapter, } from './adapters/cloudflare.js';
 export { BrowserSqliteAdapter } from './adapters/browser.js';
+export { NodeSqliteAdapter } from './adapters/node-sqlite.js';
 /**
  * MongoLite class is the main entry point for interacting with the SQLite-backed database.
  *
  * You can construct it with:
- * - A file path string — uses the built-in `better-sqlite3` adapter.
+ * - A file path string — uses the built-in `node:sqlite` adapter (`NodeSqliteAdapter`).
+ *   Requires Node.js 22.5.0+; for older runtimes, import `MongoLite` from
+ *   `@semics-tech/mongolite/better-sqlite3` instead.
  * - A `MongoLiteClientOptions` object — uses the built-in adapter with options.
  * - An `IDatabaseAdapter` instance — use a custom adapter such as
  *   `CloudflareDurableObjectAdapter` for Cloudflare Durable Objects.
@@ -33,7 +36,7 @@ export class MongoLite extends MongoLiteBase {
             super(dbPathOrOptions, options);
         }
         else {
-            super(new SQLiteDB(dbPathOrOptions), options);
+            super(new NodeSqliteAdapter(dbPathOrOptions), options);
         }
     }
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA4D,MAAM,SAAS,CAAC;AAC7F,OAAO,EAAE,SAAS,IAAI,aAAa,EAAwB,MAAM,mBAAmB,CAAC;AAErF,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOjD,OAAO,EACL,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAK7D;;;;;;;;GAQG;AACH,MAAM,OAAO,SAAU,SAAQ,aAAa;IAC1C;;;;OAIG;IACH,YACE,eAAmE,EACnE,UAAgC,EAAE;QAElC,IACE,eAAe;YACf,OAAO,eAAe,KAAK,QAAQ;YACnC,OAAQ,eAAoC,CAAC,OAAO,KAAK,UAAU;YACnE,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,IAAI,KAAK,UAAU;YAChE,OAAQ,eAAoC,CAAC,KAAK,KAAK,UAAU,EACjE,CAAC;YACD,uDAAuD;YACvD,KAAK,CAAC,eAAmC,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,QAAQ,CAAC,eAAkD,CAAC,EAAE,OAAO,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;CACF"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,SAAS,IAAI,aAAa,EAAwB,MAAM,mBAAmB,CAAC;AAErF,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOjD,OAAO,EACL,8BAA8B,GAC/B,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAI9D;;;;;;;;;;GAUG;AACH,MAAM,OAAO,SAAU,SAAQ,aAAa;IAC1C;;;;OAIG;IACH,YACE,eAAmE,EACnE,UAAgC,EAAE;QAElC,IACE,eAAe;YACf,OAAO,eAAe,KAAK,QAAQ;YACnC,OAAQ,eAAoC,CAAC,OAAO,KAAK,UAAU;YACnE,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,GAAG,KAAK,UAAU;YAC/D,OAAQ,eAAoC,CAAC,IAAI,KAAK,UAAU;YAChE,OAAQ,eAAoC,CAAC,KAAK,KAAK,UAAU,EACjE,CAAC;YACD,uDAAuD;YACvD,KAAK,CAAC,eAAmC,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,iBAAiB,CAAC,eAAkD,CAAC,EAAE,OAAO,CAAC,CAAC;QAC5F,CAAC;IACH,CAAC;CACF"}

package/package.json

@@ -1,25 +1,33 @@
 {
   "name": "@semics-tech/mongolite",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A MongoDB-like client using SQLite as a persistent store, written in TypeScript.",
-  "main": "dist/index.js",
+  "main": "dist/cjs/index.js",
   "type": "module",
   "types": "dist/index.d.ts",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/cjs/index.js"
     },
     "./cloudflare": {
       "types": "./dist/cloudflare.d.ts",
-      "default": "./dist/cloudflare.js"
+      "import": "./dist/cloudflare.js",
+      "require": "./dist/cjs/cloudflare.js"
+    },
+    "./better-sqlite3": {
+      "types": "./dist/better-sqlite3.d.ts",
+      "import": "./dist/better-sqlite3.js",
+      "require": "./dist/cjs/better-sqlite3.js"
     }
   },
   "bin": {
     "mongolite-debug": "dist/bin/mongolite-debug.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.cjs.json && cp src/cjs-package-stub.json dist/cjs/package.json",
     "test": "node --import tsx --test tests/*.test.ts",
     "test:parity": "node --import tsx --test tests/parity/*.parity.test.ts",
     "test:coverage": "c8 --reporter=lcov --reporter=text node --import tsx --test tests/*.test.ts",
@@ -63,30 +71,32 @@
   "homepage": "https://github.com/semics-tech/mongolite#readme",
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.5.0",
+    "@types/node": "^26.1.2",
     "@typescript-eslint/eslint-plugin": "^8.58.1",
     "@typescript-eslint/parser": "^8.58.1",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "eslint": "^10.1.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.1.3",
     "expect": "^30.0.0",
-    "mongodb-memory-server": "^10.4.3",
+    "mongodb-memory-server": "^11.2.0",
     "prettier": "^3.2.5",
     "tsx": "^4.19.4",
     "typescript": "^6.0.2"
   },
   "dependencies": {
     "@types/uuid": "^11.0.0",
-    "better-sqlite3": "^12.1.1",
     "bson": "^7.2.0",
     "uuid": "^14.0.0"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^13.0.2"
+  },
   "files": [
     "dist/**/*",
     "README.md"
   ],
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.5.0"
   }
 }