indexeddbshim 17.2.0 → 17.2.2

package/dist/indexeddbshim-node.cjs

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.2.0 - 8/18/2026 */
+/*! indexeddbshim - v17.2.2 - 8/18/2026 */
 
 'use strict';
 
@@ -4515,6 +4515,17 @@ IDBTransaction.prototype.__transFinishedCb = function (err, cb) {
 IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
   const me = this;
   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).
+    const dbConn = me.db && me.db.__db;
+    const supportsNonstandardTransCb = Boolean(dbConn && typeof dbConn.transaction === 'function' && dbConn.transaction.length >= 4);
+    if (!supportsNonstandardTransCb) {
+      me.__transFinishedCb(err, cb);
+      return;
+    }
     setTimeout(() => {
       me.__callTransFinishedCb(err, cb);
     }, 0);
@@ -8878,6 +8889,56 @@ function getLatestCachedWebSQLDB(name) {
   return websqlDBCache[name] && websqlDBCache[name][getLatestCachedWebSQLVersion(name)];
 }
 
+/**
+ * A cached WebSQL connection (e.g., from a prior `open()`) can keep the
+ *  underlying SQLite file handle open even after `IDBDatabase#close()`
+ *  (which only flags the connection for closing without releasing the
+ *  handle, to allow instance reuse). On Windows, deleting a file while a
+ *  handle to it is still open fails with `EBUSY`, so any cached connections
+ *  for `name` must be actually closed (and evicted, since they're no longer
+ *  usable) before attempting to remove the file.
+ * @param {string} name
+ * @param {() => void} cb
+ * @returns {void}
+ */
+function closeCachedWebSQLConnections(name, cb) {
+  if (!Object.hasOwn(websqlDBCache, name)) {
+    cb();
+    return;
+  }
+  const dbs = Object.values(websqlDBCache[name]);
+  delete websqlDBCache[name];
+  let remaining = dbs.length;
+  if (remaining === 0) {
+    cb();
+    return;
+  }
+  dbs.forEach(db => {
+    const sqliteDB = db._db && db._db._db;
+    if (!sqliteDB || !sqliteDB.close) {
+      remaining--;
+      if (remaining === 0) {
+        cb();
+      }
+      return;
+    }
+    sqliteDB.close(
+    /**
+     * @param {Error} err
+     * @returns {void}
+     */
+    err => {
+      if (err) {
+        console.warn('Error closing database connection prior to file removal: ' + err);
+      }
+      remaining--;
+      if (remaining === 0) {
+        cb();
+      }
+    });
+  });
+}
+
 /**
  * @param {OpenDatabase} __openDatabase
  * @param {string} name
@@ -8915,16 +8976,18 @@ function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, dat
     return;
   }
   if (fs && CFG.deleteDatabaseFiles !== false) {
-    fs.unlink(path.join(CFG.databaseBasePath || '', escapedDatabaseName), err => {
-      if (err && err.code !== 'ENOENT') {
-        // Ignore if file is already deleted
-        dbError({
-          code: 0,
-          message: 'Error removing database file: ' + escapedDatabaseName + ' ' + err
-        });
-        return;
-      }
-      databaseDeleted();
+    closeCachedWebSQLConnections(name, () => {
+      fs.unlink(path.join(CFG.databaseBasePath || '', escapedDatabaseName), err => {
+        if (err && err.code !== 'ENOENT') {
+          // Ignore if file is already deleted
+          dbError({
+            code: 0,
+            message: 'Error removing database file: ' + escapedDatabaseName + ' ' + err
+          });
+          return;
+        }
+        databaseDeleted();
+      });
     });
     return;
   }
@@ -9453,9 +9516,17 @@ IDBFactory.prototype.deleteDatabase = function (name) {
    * @returns {boolean}
    */
   function dbError(tx, err) {
-    if (calledDBError || err === true) {
+    if (calledDBError) {
       return false;
     }
+    // Must be set synchronously (not inside the `sysdbFinishedCbDelete` callback below) to
+    //  guard against reentrancy: `sysdbFinishedCbDelete` -> `rollback`/`commit` -> websql-configurable's
+    //  `done()` -> `currentTask.errorCallback(er)`, which is this very `dbError`, calling back into
+    //  us before the first invocation has finished. Without this, a second rollback/commit gets
+    //  issued on the shared `sysdb` connection after it has already moved on to the next queued
+    //  transaction, corrupting that connection's task queue (see issue with unrelated `open()` calls
+    //  failing/crashing after a `deleteDatabase` file-removal error).
+    calledDBError = true;
     const er = webSQLErrback(/** @type {SQLError} */err || tx);
     sysdbFinishedCbDelete(true, function () {
       req.__done = true;
@@ -9467,7 +9538,6 @@ IDBFactory.prototype.deleteDatabase = function (name) {
         cancelable: true
       });
       req.dispatchEvent(e);
-      calledDBError = true;
     });
     return false;
   }