indexeddbshim 19.0.4 → 19.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "19.0.4",
+  "version": "19.0.5",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [

package/src/IDBTransaction.js

@@ -297,6 +297,10 @@ IDBTransaction.prototype.__executeRequests = function () {
             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
@@ -332,9 +336,9 @@ IDBTransaction.prototype.__executeRequests = function () {
                     });
                 } catch (err) {
                     // The driver has already finalized the transaction (or otherwise
-                    //   rejected the call) -- nothing left to hold open, so fall back
-                    //   to a plain microtask hop for the continuation itself.
-                    queueMicrotask(cb);
+                    //   rejected the call) -- nothing left to hold open. We explicitly
+                    //   abort the transaction here.
+                    me.__abortTransaction(/** @type {Error|DOMException} */ (err));
                 }
             }
 
@@ -530,9 +534,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}
              */
@@ -567,7 +573,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 }
                 i++;
                 if (i >= me.__requests.length) {
-                    checkQueueEntry(10);
+                    checkQueueEntry(keepAliveAttempts);
                     return;
                 }
                 runQueuedRequest();
@@ -604,7 +610,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 }
                 i++;
                 if (i >= me.__requests.length) {
-                    checkQueueEntry(10);
+                    checkQueueEntry(keepAliveAttempts);
                     return;
                 }
                 keepAliveAndWait(() => {