indexeddbshim 17.2.2 → 17.3.0

package/src/IDBTransaction.js

@@ -9,7 +9,7 @@ import CFG from './CFG.js';
 
 let uniqueID = 0;
 const listeners = ['onabort', 'oncomplete', 'onerror'];
-const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
+const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'error'];
 
 /**
  * @typedef {number} Integer
@@ -26,6 +26,7 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
 /**
  * @typedef {EventTarget & {
  *   mode: "readonly"|"readwrite"|"versionchange",
+ *   durability: "default"|"strict"|"relaxed",
  *   db: import('./IDBDatabase.js').IDBDatabaseFull,
  *   on__abort: () => void,
  *   on__complete: () => void,
@@ -35,14 +36,17 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
  *   on__preabort: () => void,
  *   __abortTransaction: (err: Error|DOMException|null) => void,
  *   __executeRequests: () => void,
- *   __tx: SQLTransaction,
+ *   __tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default,
  *   __id: Integer,
  *   __active: boolean,
+ *   __handlerActive: boolean,
  *   __running: boolean,
  *   __errored: boolean,
+ *   __committed: boolean,
  *   __requests: RequestInfo[],
  *   __db: import('./IDBDatabase.js').IDBDatabaseFull,
  *   __mode: string,
+ *   __durability: string,
  *   __error: null|DOMException|Error,
  *   __objectStoreNames: import('./DOMStringList.js').DOMStringListFull,
  *   __storeHandles: {
@@ -54,6 +58,7 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
  *   __transactionEndCallback: () => void,
  *   __transactionFinished: boolean,
  *   __completed: boolean,
+ *   __transFinishedCbFired: boolean,
  *   __internal: boolean,
  *   __abortFinished: boolean,
  *   __createRequest: (
@@ -68,6 +73,7 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'db', 'error'];
  *     args?: ObjectArray
  *   ) => void,
  *   __assertActive: () => void,
+ *   commit: () => void,
  *   __addNonRequestToTransactionQueue: (
  *     callback: SQLCallback,
  *     args?: ObjectArray
@@ -98,9 +104,10 @@ const IDBTransactionAlias = IDBTransaction;
  * @param {import('./IDBDatabase.js').IDBDatabaseFull} db
  * @param {import('./DOMStringList.js').DOMStringListFull} storeNames
  * @param {string} mode
+ * @param {string} [durability]
  * @returns {IDBTransactionFull}
  */
-IDBTransaction.__createInstance = function (db, storeNames, mode) {
+IDBTransaction.__createInstance = function (db, storeNames, mode, durability = 'default') {
     /**
      * @class
      * @this {IDBTransactionFull}
@@ -113,11 +120,22 @@ IDBTransaction.__createInstance = function (db, storeNames, mode) {
         // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Debugging only
         me.__id = ++uniqueID; // for debugging simultaneous transactions
         me.__active = true;
+        // Tracks the spec's "active" flag for the purpose of validating new
+        //   requests/`commit()`: true only during the initial synchronous
+        //   script that created the transaction and during each dispatched
+        //   request's synchronous `success`/`error` handler. Deliberately
+        //   kept separate from `__active` above, which additionally (and
+        //   permanently, once false) signals that request-queue processing
+        //   has stopped -- `executeNextRequest` relies on that to know
+        //   whether it's still safe to finish the transaction normally.
+        me.__handlerActive = true;
         me.__running = false;
         me.__errored = false;
+        me.__committed = false;
         me.__requests = [];
         me.__objectStoreNames = storeNames;
         me.__mode = mode;
+        me.__durability = durability;
         me.__db = db;
         me.__error = null;
         // @ts-expect-error Part of `ShimEventTarget`
@@ -179,17 +197,34 @@ IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
  */
 IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
     const me = this;
+    if (me.__completed || me.__transFinishedCbFired) {
+        // Either this transaction's `nonstandardTransCb` installation (see
+        //   `__executeRequests`) already found `__transactionEndCallback` set
+        //   and fired `__transFinishedCb` itself in the meantime -- a race with
+        //   this call's own (possibly `setTimeout`-deferred) retry below -- or
+        //   this same call already fired it on an earlier retry. Either way,
+        //   don't fire a second commit/rollback for the same transaction.
+        //   `__transFinishedCbFired` is checked in addition to `__completed`
+        //   because `__completed` isn't set until the resulting SQL commit/
+        //   rollback round trip actually finishes, which is too late to stop
+        //   the other side from *also* firing while that's still in flight.
+        return;
+    }
     if (me.__transFinishedCb === IDBTransaction.prototype.__transFinishedCb) {
-        // Standard (3-argument) `transaction()` 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 and, if it's not
-        //  supported, just call the default (the driver auto-commits on its own).
+        // 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.transaction === 'function' && dbConn.transaction.length >= 4
+            dbConn && typeof dbConn[dbMethodName] === 'function' && dbConn[dbMethodName].length >= 4
         );
         if (!supportsNonstandardTransCb) {
+            me.__transFinishedCbFired = true;
             me.__transFinishedCb(err, cb);
             return;
         }
@@ -198,6 +233,7 @@ IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
         }, 0);
         return;
     }
+    me.__transFinishedCbFired = true;
     me.__transFinishedCb(err, cb);
 };
 /**
@@ -211,6 +247,15 @@ IDBTransaction.prototype.__executeRequests = function () {
         return;
     }
 
+    // The synchronous script that created this transaction (and
+    //   synchronously queued whatever requests it wanted to) has now
+    //   definitely returned control to the event loop -- this callback was
+    //   itself deferred via `setTimeout(..., 0)` for exactly that reason.
+    //   So the transaction's initial "active" window closes here, until the
+    //   first dispatched request's handler (see `success`/`error` below)
+    //   reopens it.
+    me.__handlerActive = false;
+
     me.__running = true;
 
     me.db.__db[me.mode === 'readonly' ? 'readTransaction' : 'transaction']( // `readTransaction` is optimized, at least in `node-websql`
@@ -248,20 +293,34 @@ IDBTransaction.prototype.__executeRequests = function () {
                 q.req.__error = null;
 
                 me.__active = true;
+                me.__handlerActive = true;
                 const e = createEvent('success');
                 q.req.dispatchEvent(e);
-                // Do not set __active flag to false yet: https://github.com/w3c/IndexedDB/issues/87
+                // Do not set __active or __handlerActive flags to false yet:
+                //   https://github.com/w3c/IndexedDB/issues/87 -- a follow-up
+                //   request queued from an `await`-based continuation of this
+                //   one (a microtask, not a further synchronous call within
+                //   this handler) must still pass `__assertActive`'s check of
+                //   both flags. `checkQueueEntry` (see `executeNextRequest`)
+                //   is what actually resets `__handlerActive`, once it's
+                //   confirmed (across its own bounded microtask wait) that no
+                //   such continuation queued anything.
                 if (e.__legacyOutputDidListenersThrowError) {
                     logError('Error', 'An error occurred in a success handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
-                    // me.__active = false;
-                    me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after success).'));
-                    return;
+                    if (!me.__committed) { // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
+                        // me.__active = false;
+                        me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after success).'));
+                        return;
+                    }
                 }
-                util.runContinuationSafely(executeNextRequest);
+                util.runContinuationSafely(advanceAfterDispatch);
             }
 
             /**
-             * @param {[tx: SQLTransaction|DOMException|Error|SQLError, err?: SQLError]} args
+             * @param {[
+             *   tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default|DOMException|Error,
+             *   err?: Error & {code?: number}
+             * ]} args
              * @returns {void}
              */
             function error (...args /* tx, err */) {
@@ -283,11 +342,18 @@ IDBTransaction.prototype.__executeRequests = function () {
                 q.req.__done = true;
                 q.req.__error = err;
                 q.req.__result = undefined; // Must be undefined if an error per `result` getter
-                q.req.addLateEventListener('error', function (e) {
-                    if (e.cancelable && e.defaultPrevented && !e.__legacyOutputDidListenersThrowError) {
-                        executeNextRequest();
+                q.req.addLateEventListener(
+                    'error',
+                    /**
+                     * @param {Event & {__legacyOutputDidListenersThrowError: boolean}} e
+                     * @returns {void}
+                     */
+                    function (e) {
+                        if (e.cancelable && e.defaultPrevented && !e.__legacyOutputDidListenersThrowError) {
+                            advanceAfterDispatch();
+                        }
                     }
-                });
+                );
                 q.req.addDefaultEventListener('error', function () {
                     if (!q.req) { // TS guard
                         return;
@@ -296,46 +362,187 @@ IDBTransaction.prototype.__executeRequests = function () {
                 });
 
                 me.__active = true;
+                me.__handlerActive = true;
                 const e = createEvent('error', err, {bubbles: true, cancelable: true});
                 q.req.dispatchEvent(e);
-                // Do not set __active flag to false yet: https://github.com/w3c/IndexedDB/issues/87
+                // Do not set __active or __handlerActive flags to false yet --
+                //   see the matching comment in `success`, above.
                 if (e.__legacyOutputDidListenersThrowError) {
                     logError('Error', 'An error occurred in an error handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
                     e.preventDefault(); // Prevent 'error' default as steps indicate we should abort with `AbortError` even without cancellation
+                    if (me.__committed) { // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
+                        util.runContinuationSafely(advanceAfterDispatch);
+                        return;
+                    }
                     me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after error).'));
                 }
             }
 
+            /**
+             * Sets up `q` for the current queue index and, for a genuine
+             *   request (not one of our internal non-request queue entries),
+             *   deactivates the transaction for the duration of its
+             *   (possibly async) work. Returns `false` if there's nothing to
+             *   do (an already-aborted request).
+             * @returns {boolean}
+             */
+            function prepareNextRequest () {
+                q = me.__requests[i];
+                if (!q.req) {
+                    // Non-standard, non-`IDBRequest` queue entries (e.g.
+                    //   the internal `onupgradeneeded` dispatch op in
+                    //   `IDBFactory.js`) dispatch straight to user code
+                    //   without going through `success`/`error` below --
+                    //   unlike those, they never restore `__active`/
+                    //   `__handlerActive` to `true` before doing so, so
+                    //   they rely on the flags being left as they are
+                    //   (not reset here).
+                    return true;
+                }
+                if (q.req.__done) { // Avoid continuing with aborted requests
+                    return false;
+                }
+                // We're now handing off to (possibly async) work for
+                //   this request, so the transaction is no longer active
+                //   until its own `success`/`error` dispatch (below)
+                //   sets these flags again -- a check that happens to
+                //   run during this gap (e.g. `commit()` called from an
+                //   unrelated `setTimeout`) must see the transaction as
+                //   inactive, per spec.
+                me.__active = false;
+                me.__handlerActive = false;
+                return true;
+            }
+
             /**
              * @returns {void}
              */
-            function executeNextRequest () {
+            function launchQueuedOp () {
+                try {
+                    if (!q.req) {
+                        q.op(tx, q.args, () => util.runContinuationSafely(executeNextRequest), error);
+                        return;
+                    }
+                    q.op(tx, q.args, success, error, executeNextRequest);
+                } catch (e) {
+                    error(/** @type {Error} */ (e));
+                }
+            }
+
+            /**
+             * @returns {void}
+             */
+            function runQueuedRequest () {
+                if (!prepareNextRequest()) {
+                    return;
+                }
+                launchQueuedOp();
+            }
+
+            /**
+             * A request's `success`/`error` event fires (and any `await`-based
+             *   continuation watching it resolves) before this check runs, since
+             *   that dispatch happens synchronously above, one call frame up.
+             *   If such a continuation queues a follow-up request, it does so
+             *   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.
+             *   Applies to `readonly` transactions too, not just `readwrite`/
+             *   `versionchange`: a `readonly` transaction's `complete` event
+             *   can otherwise fire synchronously, immediately after its last
+             *   request's `success` handler returns -- before an `await`-based
+             *   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.
+             * @param {number} attemptsLeft
+             * @returns {void}
+             */
+            function checkQueueEntry (attemptsLeft) {
                 if (me.__errored || me.__requestsFinished) {
-                    // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                     return;
                 }
-                i++;
-                if (i >= me.__requests.length) {
+                if (i < me.__requests.length) {
+                    runQueuedRequest();
+                    return;
+                }
+                if (attemptsLeft <= 0) {
                     // All requests in the transaction are done
                     me.__requests = [];
                     if (me.__active) {
                         requestsFinished();
                     }
-                } else {
-                    try {
-                        q = me.__requests[i];
-                        if (!q.req) {
-                            q.op(tx, q.args, () => util.runContinuationSafely(executeNextRequest), error);
-                            return;
-                        }
-                        if (q.req.__done) { // Avoid continuing with aborted requests
-                            return;
-                        }
-                        q.op(tx, q.args, success, error, executeNextRequest);
-                    } catch (e) {
-                        error(/** @type {Error} */ (e));
-                    }
+                    return;
+                }
+                queueMicrotask(() => {
+                    checkQueueEntry(attemptsLeft - 1);
+                });
+            }
+
+            /**
+             * @returns {void}
+             */
+            function executeNextRequest () {
+                if (me.__errored || me.__requestsFinished) {
+                    // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
+                    return;
+                }
+                i++;
+                if (i >= me.__requests.length) {
+                    checkQueueEntry(10);
+                    return;
+                }
+                runQueuedRequest();
+            }
+
+            /**
+             * Same as `executeNextRequest`, but used specifically as the
+             *   continuation from a request's own `success`/`error` dispatch
+             *   (see call sites above): gives same-tick microtasks scheduled
+             *   from within that handler (e.g. a plain
+             *   `Promise.resolve().then(...)`) a chance to run -- and still
+             *   observe the transaction as active -- before we deactivate it
+             *   again for the next queued request, per
+             *   https://github.com/w3c/IndexedDB/issues/87.
+             *
+             *   This is safe for `readonly` transactions too only because
+             *   `__executeRequests` now passes a `nonstandardTransCb` to
+             *   `readTransaction()` (matching `.transaction()`) and
+             *   `requestsFinished` defers `readonly` completion through
+             *   `__transactionEndCallback`/`__callTransFinishedCb` the same
+             *   way `readwrite` already did: the WebSQL driver's
+             *   "optimized" `readTransaction` path used to finalize the
+             *   underlying transaction as soon as no further `executeSql`
+             *   call was already in flight or queued, which -- before that
+             *   fix -- meant even a microtask-long gap here would let the
+             *   driver consider the transaction done, silently dropping
+             *   every subsequent queued request (never firing
+             *   `success`/`error` for it at all).
+             * @returns {void}
+             */
+            function advanceAfterDispatch () {
+                if (me.__errored || me.__requestsFinished) {
+                    return;
+                }
+                i++;
+                if (i >= me.__requests.length) {
+                    checkQueueEntry(10);
+                    return;
                 }
+                queueMicrotask(() => {
+                    if (me.__errored || me.__requestsFinished) {
+                        return;
+                    }
+                    if (!prepareNextRequest()) {
+                        return;
+                    }
+                    launchQueuedOp();
+                });
             }
 
             executeNextRequest();
@@ -345,7 +552,7 @@ IDBTransaction.prototype.__executeRequests = function () {
             if (webSQLErr === true) { // Not a genuine SQL error
                 return;
             }
-            const err = webSQLErrback(/** @type {SQLError} */ (webSQLErr));
+            const err = webSQLErrback(/** @type {Error & {code?: number}} */ (webSQLErr));
             me.__abortTransaction(err);
         },
         function () {
@@ -359,22 +566,46 @@ IDBTransaction.prototype.__executeRequests = function () {
                 me.__transactionFinished = true;
                 return;
             }
-            if (me.__transactionEndCallback && !me.__completed) {
+            if (me.__transactionEndCallback && !me.__completed && !me.__transFinishedCbFired) {
+                me.__transFinishedCbFired = true;
                 me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
             }
         },
         function (currentTask, err, done, rollback, commit) {
-            if (currentTask.readOnly || err) {
+            if (err) {
                 return true;
             }
-            me.__transFinishedCb = function (err, cb) {
-                if (err) {
-                    rollback(err, cb);
-                } else {
-                    commit(cb);
+            // `readonly` transactions never hold a real SQL transaction open
+            //   (see `WebSQLTransaction`'s constructor skipping `BEGIN;` for
+            //   them), so there's no commit/rollback round trip to defer --
+            //   `done` itself is the "genuinely finished" signal for them,
+            //   called synchronously once `requestsFinished` (via
+            //   `__callTransFinishedCb`) confirms no further request is
+            //   coming.
+            me.__transFinishedCb = currentTask.readOnly
+                ? function (err, cb) {
+                    done(err);
+                    if (cb) {
+                        cb();
+                    }
                 }
-            };
-            if (me.__transactionEndCallback && !me.__completed) {
+                : function (err, cb) {
+                    if (err) {
+                        rollback(err, cb);
+                    } else {
+                        commit(cb);
+                    }
+                };
+            // Guarded by `__transFinishedCbFired`, not just `__completed`: this
+            //   installation can race `IDBTransaction.prototype.__callTransFinishedCb`'s
+            //   own `setTimeout` retry (see there) -- both watch for
+            //   `__transFinishedCb` to become installed and `__transactionEndCallback`
+            //   to become set, and either could observe both conditions first.
+            //   `__completed` alone isn't set until the resulting SQL commit/rollback
+            //   round trip actually finishes, which is too late to prevent the other
+            //   side from *also* firing in the meantime.
+            if (me.__transactionEndCallback && !me.__completed && !me.__transFinishedCbFired) {
+                me.__transFinishedCbFired = true;
                 me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
             }
             return false;
@@ -386,6 +617,7 @@ IDBTransaction.prototype.__executeRequests = function () {
      */
     function requestsFinished () {
         me.__active = false;
+        me.__handlerActive = false;
         me.__requestsFinished = true;
 
         /**
@@ -412,16 +644,27 @@ IDBTransaction.prototype.__executeRequests = function () {
                 me.__storeHandles = {};
             }
         }
-        if (me.mode === 'readwrite') {
+        if (me.mode === 'readwrite' || me.mode === 'readonly') {
             if (me.__transactionFinished) {
                 complete();
                 return;
             }
             me.__transactionEndCallback = complete;
-            return;
-        }
-        if (me.mode === 'readonly') {
-            complete();
+            // The underlying SQL driver's own "queue empty" check
+            //   (`nonstandardTransCb`, above) typically already ran and
+            //   installed the real `__transFinishedCb` *before* this point --
+            //   it fires synchronously once the last SQL batch's results are
+            //   processed, whereas `requestsFinished` can now be reached only
+            //   after `checkQueueEntry`'s bounded microtask wait, i.e. later.
+            //   When that happens, its check for `me.__transactionEndCallback`
+            //   (not yet set at that earlier time) finds nothing to do and
+            //   just returns, so nothing else will ever re-trigger the actual
+            //   commit unless this explicitly does so now. For `readonly`,
+            //   `__transFinishedCb` (installed by the `nonstandardTransCb`
+            //   passed to `readTransaction()`, above) just calls the WebSQL
+            //   driver's own `done` -- there's no real commit/rollback SQL
+            //   step for a `readonly` transaction.
+            me.__callTransFinishedCb(me.__errored, complete);
             return;
         }
         const ev = /** @type {Event & {complete: () => void}} */ (
@@ -449,10 +692,13 @@ IDBTransaction.prototype.__createRequest = function (source) {
 
 /**
  * @typedef {(
- *   tx: SQLTransaction,
+ *   tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default,
  *   args: ObjectArray,
  *   success: (result?: any, req?: import('./IDBRequest.js').IDBRequestFull) => void,
- *   error: (tx: SQLTransaction|Error|DOMException|SQLError, err?: SQLError) => void,
+ *   error: (
+ *     tx: import('websql-configurable/lib/websql/WebSQLTransaction.js').default|Error|DOMException,
+ *     err?: Error & {code?: number}
+ *   ) => void,
  *   executeNextRequest?: () => void
  * ) => void} SQLCallback
  */
@@ -504,10 +750,11 @@ IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
 
 /**
  * @throws {DOMException}
+ * @this {IDBTransactionFull}
  * @returns {void}
  */
 IDBTransaction.prototype.__assertActive = function () {
-    if (!this.__active) {
+    if (!this.__active || !this.__handlerActive || this.__committed) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
 };
@@ -588,7 +835,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         ).forEach(function (store) {
             // Store was already created so we restore to name before the rename
             if ('__pendingName' in store &&
-                me.db.__oldObjectStoreNames.indexOf(store.__pendingName) > -1 // eslint-disable-line unicorn/prefer-includes -- Not supported
+                me.db.__oldObjectStoreNames.indexOf(/** @type {string} */ (store.__pendingName)) > -1 // eslint-disable-line unicorn/prefer-includes -- Not supported
             ) {
                 store.__name = store.__originalName;
             }
@@ -599,7 +846,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
             ).forEach(function (index) {
                 // Index was already created so we restore to name before the rename
                 if ('__pendingName' in index &&
-                    store.__oldIndexNames.indexOf(index.__pendingName) > -1 // eslint-disable-line unicorn/prefer-includes -- Not supported
+                    store.__oldIndexNames.indexOf(/** @type {string} */ (index.__pendingName)) > -1 // eslint-disable-line unicorn/prefer-includes -- Not supported
                 ) {
                     index.__name = index.__originalName;
                 }
@@ -622,8 +869,8 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
     }
 
     /**
-     * @param {SQLTransaction|null} [tx]
-     * @param {SQLResultSet|SQLError|{code: 0}} [errOrResult]
+     * @param {import('websql-configurable/lib/websql/WebSQLTransaction.js').default|null} [tx]
+     * @param {import('websql-configurable/lib/websql/WebSQLResultSet.js').default|(Error & {code?: number})|{code: 0}} [errOrResult]
      * @returns {void}
      */
     function abort (tx, errOrResult) {
@@ -652,7 +899,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                 q.req.__error = createDOMException('AbortError', 'A request was aborted (an unfinished request).');
                 const reqEvt = createEvent('error', q.req.__error, {bubbles: true, cancelable: true});
                 return new SyncPromise(
-                    /** @type {() => void} */
+                    /** @type {(resolve: (value?: any) => void) => void} */
                     (resolve) => {
                         setTimeout(() => {
                             if (!q.req) { // TS guard
@@ -696,7 +943,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                     'ROLLBACK',
                     [],
                     abort,
-                    /** @type {SQLStatementErrorCallback} */ (abort)
+                    /** @type {import('websql-configurable/lib/websql/WebSQLTransaction.js').SqlErrorCallback} */ (abort)
                 ); // Not working in some circumstances, even in Node
             } catch (err) {
                 // Browser errs when transaction has ended and since it most likely already erred here,
@@ -720,14 +967,34 @@ IDBTransaction.prototype.abort = function () {
     }
     if (CFG.DEBUG) { console.log('The transaction was aborted', me); }
     IDBTransaction.__assertNotFinished(me);
+    if (me.__committed) {
+        throw createDOMException('InvalidStateError', 'The transaction has already been committed');
+    }
     me.__abortTransaction(null);
 };
 
+/**
+ * @see https://www.w3.org/TR/IndexedDB/#dom-idbtransaction-commit
+ * @this {IDBTransactionFull}
+ * @returns {void}
+ */
+IDBTransaction.prototype.commit = function () {
+    const me = this;
+    if (!(me instanceof IDBTransaction)) {
+        throw new TypeError('Illegal invocation');
+    }
+    if (!me.__active || !me.__handlerActive || me.__committed) {
+        throw createDOMException('InvalidStateError', 'Failed to execute \'commit\' on \'IDBTransaction\': The transaction is not active.');
+    }
+    if (CFG.DEBUG) { console.log('The transaction was explicitly committed', me); }
+    me.__committed = true;
+};
+
 IDBTransaction.prototype[Symbol.toStringTag] = 'IDBTransactionPrototype';
 
 /**
  *
- * @param {IDBTransactionFull|undefined} tx
+ * @param {IDBTransactionFull|null|undefined} tx
  * @returns {void}
  */
 IDBTransaction.__assertVersionChange = function (tx) {
@@ -737,7 +1004,7 @@ IDBTransaction.__assertVersionChange = function (tx) {
 };
 /**
  *
- * @param {IDBTransactionFull} tx
+ * @param {IDBTransactionFull|null} tx
  * @throws {DOMException}
  * @returns {void}
  */
@@ -749,7 +1016,7 @@ IDBTransaction.__assertNotVersionChange = function (tx) {
 
 /**
  *
- * @param {IDBTransactionFull|undefined} tx
+ * @param {IDBTransactionFull|null|undefined} tx
  * @throws {DOMException}
  * @returns {void}
  */
@@ -778,12 +1045,12 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
 
 /**
  *
- * @param {IDBTransactionFull|undefined} tx
+ * @param {IDBTransactionFull|null|undefined} tx
  * @throws {DOMException}
  * @returns {void}
  */
 IDBTransaction.__assertActive = function (tx) {
-    if (!tx || !tx.__active) {
+    if (!tx || !tx.__active || tx.__committed) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
 };
@@ -800,6 +1067,7 @@ IDBTransaction.prototype.__getParent = function () {
 /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
 util.defineOuterInterface(IDBTransaction.prototype, listeners);
 util.defineReadonlyOuterInterface(IDBTransaction.prototype, readonlyProperties);
+util.setOperationNames(IDBTransaction.prototype);
 
 Object.defineProperty(IDBTransaction.prototype, 'constructor', {
     enumerable: false,