indexeddbshim 17.0.0 → 17.1.0

package/src/Key.js

@@ -283,14 +283,22 @@ const types = {
                 encoded[i] = encodedItem;
             }
             encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
-            return keyTypeToEncodedChar.array + '-' + JSON.stringify(encoded);
+            let encodedKey = JSON.stringify(encoded);
+            if (CFG.escapeNULForSQLiteStatements === false) {
+                encodedKey = encodedKey.replaceAll(String.raw`\u0000`, '\0');
+            }
+            return keyTypeToEncodedChar.array + '-' + encodedKey;
         },
         /**
          * @param {string} key
          * @returns {ValueTypeArray}
          */
         decode (key) {
-            const decoded = JSON.parse(key.slice(2));
+            let decodedKey = key.slice(2);
+            if (CFG.escapeNULForSQLiteStatements === false) {
+                decodedKey = decodedKey.replaceAll('\0', String.raw`\u0000`);
+            }
+            const decoded = JSON.parse(decodedKey);
             decoded.pop(); // remove the extra item
             for (let i = 0; i < decoded.length; i++) {
                 const item = decoded[i];

package/src/node-UnicodeIdentifiers.js

@@ -13,7 +13,11 @@ CFG.win = {openDatabase: nodeWebSQL};
  * @returns {import('./setGlobalVars.js').ShimmedObject|Window}
  */
 const __setGlobalVars = function (idb, initialConfig = {}) {
-    const obj = setGlobalVars(idb, {fs, ...initialConfig});
+    const obj = setGlobalVars(idb, {
+        fs,
+        escapeNULForSQLiteStatements: false,
+        ...initialConfig
+    });
     /* istanbul ignore next -- TS guard */
     if (!obj.shimIndexedDB) {
         return obj;

package/src/node.js

@@ -12,7 +12,11 @@ CFG.win = {openDatabase: nodeWebSQL};
  * @returns {import('./setGlobalVars.js').ShimmedObject|Window}
  */
 const __setGlobalVars = function (idb, initialConfig = {}) {
-    return setGlobalVars(idb, {fs, ...initialConfig});
+    return setGlobalVars(idb, {
+        fs,
+        escapeNULForSQLiteStatements: false,
+        ...initialConfig
+    });
 };
 
 export default __setGlobalVars;

package/src/nodeSQLiteDatabase.js

@@ -0,0 +1,174 @@
+import Database from 'better-sqlite3';
+
+/**
+ *
+ */
+class SQLiteResult {
+    /**
+     * @param {Error|null|undefined} error
+     * @param {number|undefined} [insertId]
+     * @param {number} [rowsAffected]
+     * @param {object[]} [rows]
+     */
+    constructor (error, insertId, rowsAffected, rows) {
+        this.error = error;
+        this.insertId = insertId;
+        this.rowsAffected = rowsAffected;
+        this.rows = rows;
+    }
+}
+
+const READ_ONLY_ERROR = new Error(
+    'could not prepare statement (23 not authorized)'
+);
+
+/**
+ * @typedef {(sql: string, duration: number) => void} SQLProfileCallback
+ */
+
+/**
+ * @typedef {((sql: string) => void)|undefined} SQLTraceCallback
+ */
+
+/**
+ * @param {string} name
+ * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
+ * @returns {void}
+ */
+function SQLiteDatabase (name, opts = {}) {
+    /** @type {import('better-sqlite3').Database} */
+    const db = new Database(name);
+
+    /** @type {SQLTraceCallback} */
+    // eslint-disable-next-line prefer-destructuring -- TS
+    let trace = opts.trace;
+    /** @type {SQLProfileCallback|undefined} */
+    // eslint-disable-next-line prefer-destructuring -- TS
+    let profile = opts.profile;
+
+    if (opts.busyTimeout) {
+        db.pragma('busy_timeout = ' + Number(opts.busyTimeout));
+    }
+
+    // Kept untyped (rather than the better-sqlite3 `Database` type) since that
+    //  type is internal to `@types/better-sqlite3` and can't be named in this
+    //  file's emitted declaration.
+    this._db = /** @type {any} */ ({
+        _db: db,
+        /**
+         * Compatibility with node-sqlite3's configure API.
+         * @param {'busyTimeout'|'trace'|'profile'} option
+         * @param {number|((sql: string, duration?: number) => void)} value
+         * @returns {void}
+         */
+        configure (option, value) {
+            if (option === 'busyTimeout') {
+                db.pragma('busy_timeout = ' + Number(/** @type {number} */ (value)));
+                return;
+            }
+            if (option === 'trace') {
+                trace = /** @type {(sql: string) => void} */ (value);
+                return;
+            }
+            if (option === 'profile') {
+                profile = /** @type {SQLProfileCallback} */ (value);
+            }
+        },
+        /**
+         * Compatibility with callback-oriented close semantics.
+         * @param {(err?: Error|null) => void} [cb]
+         * @returns {void}
+         */
+        close (cb) {
+            try {
+                db.close();
+                if (cb) {
+                    return cb(null);
+                }
+            } catch (err) {
+                if (cb) {
+                    return cb(/** @type {Error} */ (err));
+                }
+            }
+            return undefined;
+        },
+        getTrace () {
+            return trace;
+        },
+        getProfile () {
+            return profile;
+        }
+    });
+}
+
+/**
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} sql
+ * @param {unknown[]} args
+ * @returns {object[]}
+ */
+function runSelect (db, sql, args) {
+    const stmt = db.prepare(sql);
+    return stmt.reader ? /** @type {object[]} */ (stmt.all(...args)) : [];
+}
+
+/**
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} sql
+ * @param {unknown[]} args
+ * @returns {import('better-sqlite3').RunResult}
+ */
+function runNonSelect (db, sql, args) {
+    const stmt = db.prepare(sql);
+    return stmt.run(...args);
+}
+
+/**
+ * @param {{sql: string, args: unknown[]}[]} queries
+ * @param {boolean} readOnly
+ * @param {(err: Error|null, results?: SQLiteResult[]) => void} callback
+ * @returns {void}
+ */
+SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
+    const db = this._db._db;
+    const len = queries.length;
+    const results = Array.from({length: len});
+
+    for (let i = 0; i < len; i++) {
+        const query = queries[i];
+        const {sql, args} = query;
+        const isSelect = (/^\s*SELECT\b/iu).test(sql);
+        if (readOnly && !isSelect) {
+            results[i] = new SQLiteResult(READ_ONLY_ERROR);
+            continue;
+        }
+        const trace = this._db.getTrace();
+        const profile = this._db.getProfile();
+        // eslint-disable-next-line unicorn/prefer-bigint-literals -- `0n` needs ES2020+ target for tsc
+        const start = profile ? process.hrtime.bigint() : BigInt(0);
+        try {
+            if (trace) {
+                trace(sql);
+            }
+            if (isSelect) {
+                const rows = runSelect(db, sql, args);
+                results[i] = new SQLiteResult(null, undefined, 0, rows);
+            } else {
+                const executionResult = runNonSelect(db, sql, args);
+                const insertId = Number(executionResult.lastInsertRowid);
+                results[i] = new SQLiteResult(null, insertId, executionResult.changes, []);
+            }
+        } catch (err) {
+            results[i] = new SQLiteResult(/** @type {Error} */ (err));
+        } finally {
+            if (profile) {
+                profile(sql, Number(process.hrtime.bigint() - start));
+            }
+        }
+    }
+    queueMicrotask(() => {
+        callback(null, results);
+    });
+};
+
+export default SQLiteDatabase;

package/src/nodeWebSQL.js

@@ -1,5 +1,5 @@
 import customOpenDatabase from 'websql-configurable/custom/index.js';
-import SQLiteDatabase from 'websql-configurable/lib/sqlite/SQLiteDatabase.js';
+import SQLiteDatabase from './nodeSQLiteDatabase.js';
 import CFG from './CFG.js';
 
 /**
@@ -12,11 +12,9 @@ function wrappedSQLiteDatabase (name) {
         db._db.configure('busyTimeout', /** @type {number} */ (CFG.sqlBusyTimeout)); // Default is 1000
     }
     if (CFG.sqlTrace) {
-        // @ts-expect-error native API?
         db._db.configure('trace', CFG.sqlTrace);
     }
     if (CFG.sqlProfile) {
-        // @ts-expect-error native API?
         db._db.configure('profile', CFG.sqlProfile);
     }
     return db;

package/src/util.js

@@ -51,7 +51,12 @@ function escapeNameForSQLiteIdentifier (arg) {
  * @returns {string}
  */
 function escapeSQLiteStatement (arg) {
-    return escapeUnmatchedSurrogates(arg.replaceAll('^', '^^').replaceAll('\0', '^0'));
+    const escaped = arg.replaceAll('^', '^^');
+    return escapeUnmatchedSurrogates(
+        CFG.escapeNULForSQLiteStatements === false
+            ? escaped
+            : escaped.replaceAll('\0', '^0')
+    );
 }
 
 /**
@@ -59,7 +64,11 @@ function escapeSQLiteStatement (arg) {
  * @returns {string}
  */
 function unescapeSQLiteResponse (arg) {
-    return unescapeUnmatchedSurrogates(arg)
+    const unescaped = unescapeUnmatchedSurrogates(arg);
+    if (CFG.escapeNULForSQLiteStatements === false) {
+        return unescaped.replaceAll('^^', '^');
+    }
+    return unescaped
         .replaceAll(/(\^+)0/gu, (_, esc) => {
             return esc.length % 2
                 ? esc.slice(1) + '\0'
@@ -548,6 +557,56 @@ function isNullish (v) {
     return v === null || v === undefined;
 }
 
+/**
+ * Cursor/request continuation chains can call each other synchronously
+ * (e.g. walking a large prefetched buffer, or advancing many interleaved
+ * cursors in one transaction) which, for large enough record counts, can
+ * exceed the JS engine's call stack ("Maximum call stack size exceeded").
+ *
+ * This can't be fixed by deferring continuations to a microtask/macrotask:
+ * the transaction machinery synchronously checks (once the current call
+ * stack unwinds) whether there are any pending requests left in order to
+ * decide it's safe to commit; deferring a continuation opens a real gap in
+ * which that check runs first and the transaction completes prematurely,
+ * with the deferred continuation then acting on an already-finished
+ * transaction (a hang, since it can never resolve).
+ *
+ * Instead, this implements a true trampoline: the first call starts a
+ * synchronous work queue and drains it in a flat loop; any call made while
+ * already draining (i.e. a continuation triggering another continuation)
+ * is simply appended to that same queue and returns immediately instead of
+ * recursing. This keeps everything synchronous (so no completion-check
+ * race is introduced) while preventing the call stack from growing with
+ * each successive continuation.
+ */
+const continuationState = {
+    /** @type {Array<() => void>|null} */
+    queue: null
+};
+
+/**
+ * @param {() => void} fn
+ * @returns {void}
+ */
+function runContinuationSafely (fn) {
+    if (continuationState.queue) {
+        continuationState.queue.push(fn);
+        return;
+    }
+    const queue = [fn];
+    continuationState.queue = queue;
+    try {
+        while (queue.length) {
+            const next = /** @type {() => void} */ (queue.shift());
+            next();
+        }
+    } finally {
+        // Ensure a thrown exception can't leave the queue permanently
+        // stuck (which would silently swallow all future continuations).
+        continuationState.queue = null;
+    }
+}
+
 export {escapeSQLiteStatement, unescapeSQLiteResponse,
     escapeDatabaseNameForSQLAndFiles, unescapeDatabaseNameForSQLAndFiles,
     escapeStoreNameForSQL, escapeIndexNameForSQL, escapeIndexNameForSQLKeyColumn,
@@ -558,4 +617,4 @@ export {escapeSQLiteStatement, unescapeSQLiteResponse,
     defineListenerProperties, defineReadonlyProperties,
     isValidKeyPath, enforceRange,
     convertToDOMString, convertToSequenceDOMString,
-    isNullish};
+    isNullish, runContinuationSafely};