indexeddbshim 19.0.3 → 19.0.5

package/dist/indexeddbshim-node.cjs

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v19.0.3 - 9/15/2026 */
+/*! indexeddbshim - v19.0.5 - 9/17/2026 */
 
 'use strict';
 
@@ -1446,7 +1446,7 @@ const CFG = /** @type {ConfigValues} */{};
 'UnicodeIDStart',
 // In the non-Unicode builds, defaults to /[$0-9A-Z_a-z]/
 'UnicodeIDContinue',
-// Used by SCA.js for optional restructuring of typeson-registry
+// Used by Sca.js for optional restructuring of typeson-registry
 //   Structured Cloning Algorithm; should only be needed for ensuring data
 //   created in 3.* versions of IndexedDBShim continue to work; see the
 //   library `typeson-registry-sca-reverter` to get a function to do this
@@ -4941,6 +4941,7 @@ const readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'e
  *   __requestsFinished: boolean,
  *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
  *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
+ *   __usesStandardDriver: () => boolean,
  *   __transactionEndCallback: (() => void)|undefined,
  *   __transactionFinished: boolean,
  *   __completed: boolean,
@@ -5078,6 +5079,27 @@ IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
   cb(Boolean(err));
 };
 
+/**
+ * A standard (3-argument) `transaction()`/`readTransaction()` implementation
+ *   (browser WebSQL, `cordova-plugin-sqlite-2`, etc.) never invokes the
+ *   non-standard 4th callback that installs the real `__transFinishedCb`,
+ *   and finalizes its own underlying SQL transaction synchronously, as soon
+ *   as it sees no further `executeSql` call already in flight or queued --
+ *   with no way for it to know a JS-level continuation (e.g. an
+ *   `await`-deferred follow-up request) is still coming. Detected via
+ *   arity, checking whichever of the two methods this transaction's own
+ *   mode actually uses.
+ * @this {IDBTransactionFull}
+ * @returns {boolean}
+ */
+IDBTransaction.prototype.__usesStandardDriver = function () {
+  const me = this;
+  const dbConn = me.db && me.db.__db;
+  const dbMethodName = me.mode === 'readonly' ? 'readTransaction' : 'transaction';
+  const supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn[dbMethodName] === 'function' && dbConn[dbMethodName].length >= 4);
+  return !supportsNonstandardTransCb;
+};
+
 /**
  * In Node, the real (SQL-commit-capable) `__transFinishedCb` is only
  * installed once the underlying WebSQL driver's own SQL-queue-idle check
@@ -5112,17 +5134,11 @@ IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
     return;
   }
   if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
-    // Standard (3-argument) `transaction()`/`readTransaction()` implementations
-    //  (browser WebSQL, `cordova-plugin-sqlite-2`, etc.) never invoke the
-    //  non-standard 4th callback that installs the real `__transFinishedCb`,
-    //  so waiting for it here would defer forever. Detect that via arity
-    //  (checking whichever of the two methods this transaction's own mode
-    //  actually uses -- see `__executeRequests`) and, if it's not supported,
-    //  just call the default (the driver auto-commits on its own).
-    const dbConn = me.db && me.db.__db;
-    const dbMethodName = me.mode === 'readonly' ? 'readTransaction' : 'transaction';
-    const supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn[dbMethodName] === 'function' && dbConn[dbMethodName].length >= 4);
-    if (!supportsNonstandardTransCb) {
+    // Waiting here for the non-standard 4th callback to install the real
+    //  `__transFinishedCb` would defer forever on a standard driver, which
+    //  never invokes it -- call the default instead (the driver auto-commits
+    //  on its own).
+    if (me.__usesStandardDriver()) {
       me.__transFinishedCbFired = true;
       me.__transFinishedCb(err, cb);
       return;
@@ -5161,10 +5177,56 @@ IDBTransaction.prototype.__executeRequests = function () {
   // `readTransaction` is optimized, at least in `node-websql`
   function executeRequests(tx) {
     me.__tx = tx;
+    const isStandardDriver = me.__usesStandardDriver();
     /** @type {RequestInfo} */
     let q,
       i = -1;
 
+    // On a standard driver, `keepAliveAndWait` issues a SQL query, which
+    //   is a macrotask. Otherwise it issues ten microtasks.
+    const keepAliveAttempts = isStandardDriver ? 1 : 10;
+
+    /**
+     * A continuation that must still be able to observe the
+     *   transaction as safe to extend (e.g., re-checking whether an
+     *   `await`-based follow-up request has arrived yet, or giving a
+     *   same-tick microtask scheduled from a handler a chance to run
+     *   first) can normally just be deferred via `queueMicrotask`.
+     *   That alone isn't safe on a standard (3-argument) driver,
+     *   though: it finalizes its own underlying SQL transaction
+     *   synchronously, as soon as it sees no further `executeSql`
+     *   call already in flight or queued, and a microtask hop by
+     *   itself never issues one -- so the driver already considers
+     *   the transaction done by the time the deferred continuation
+     *   runs, silently dropping whatever it tries to do next. Issuing
+     *   a harmless `SELECT 1` instead keeps the driver's own queue
+     *   non-empty across that same gap, at the cost of a real SQL
+     *   round trip; Node's driver doesn't need this since its real
+     *   commit/rollback is already deferred separately, via
+     *   `nonstandardTransCb`.
+     * @param {() => void} cb
+     * @returns {void}
+     */
+    function keepAliveAndWait(cb) {
+      if (!isStandardDriver) {
+        queueMicrotask(cb);
+        return;
+      }
+      try {
+        tx.executeSql('SELECT 1', [], function () {
+          cb();
+        }, function () {
+          cb();
+          return false; // Don't roll back the transaction over a keep-alive no-op
+        });
+      } catch (err) {
+        // The driver has already finalized the transaction (or otherwise
+        //   rejected the call) -- nothing left to hold open. We explicitly
+        //   abort the transaction here.
+        me.__abortTransaction(/** @type {Error|DOMException} */err);
+      }
+    }
+
     /**
      * @typedef {unknown} IDBRequestResult
      */
@@ -5353,9 +5415,9 @@ IDBTransaction.prototype.__executeRequests = function () {
      *   from a microtask -- so if the JS-level queue is merely found
      *   empty here, that doesn't yet mean no more work is coming, only
      *   that none has been queued *yet*. Re-check across a small, bounded
-     *   number of further microtask turns (letting a typical `await`
-     *   chain like `await store.put(...); await store.get(...)` catch
-     *   up) before finally concluding the transaction is genuinely done.
+     *   number of further turns (see `keepAliveAndWait`, letting a typical
+     *   `await` chain like `await store.put(...); await store.get(...)`
+     *   catch up) before finally concluding the transaction is genuinely done.
      *   Applies to `readonly` transactions too, not just `readwrite`/
      *   `versionchange`: a `readonly` transaction's `complete` event
      *   can otherwise fire synchronously, immediately after its last
@@ -5363,9 +5425,11 @@ IDBTransaction.prototype.__executeRequests = function () {
      *   consumer of that same handler (e.g. one that resolves a
      *   promise from within `onsuccess` and only attaches `oncomplete`
      *   afterward) ever gets a turn to run, so it can miss `complete`
-     *   entirely. `readonly` requests don't hold a real SQL
-     *   transaction open, though, so there's no file-lock/connection
-     *   collision risk in waiting the same bounded amount here.
+     *   afterward) ever gets a turn to run, so it can miss `complete`
+     *   entirely. On a non-standard driver, `readonly` requests don't hold
+     *   a real SQL transaction open, so there's no file-lock/connection
+     *   collision risk. On a standard driver, the wait now issues real SQL
+     *   inside the read transaction, so this does carry a slight risk.
      * @param {number} attemptsLeft
      * @returns {void}
      */
@@ -5385,7 +5449,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         }
         return;
       }
-      queueMicrotask(() => {
+      keepAliveAndWait(() => {
         checkQueueEntry(attemptsLeft - 1);
       });
     }
@@ -5400,7 +5464,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       }
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
       runQueuedRequest();
@@ -5437,10 +5501,10 @@ IDBTransaction.prototype.__executeRequests = function () {
       }
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
-      queueMicrotask(() => {
+      keepAliveAndWait(() => {
         if (me.__errored || me.__requestsFinished) {
           return;
         }
@@ -13054,10 +13118,11 @@ function setGlobalVars(idb, initialConfig) {
             setNonIDBGlobals();
           }
         }
-        /* istanbul ignore next -- TS guard */
+        /* c8 ignore start -- TS guard */
         if (!IDB.shimIndexedDB) {
           return;
         }
+        /* c8 ignore stop -- TS guard */
         IDB.shimIndexedDB.__setConnectionQueueOrigin();
       }
     };