indexeddbshim 17.2.1 → 17.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.2.1",
+  "version": "17.2.2",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -48,6 +48,7 @@
     "clean-w3c": "rimraf D_^D^B2* D_db* D_test* D_about* D_^I^D^B* D_blank* D_database_name* D_idbtransaction* D_x D_x.sqlite D_y D_y.sqlite D_webworker* D_http*",
     "clean-w3cOld": "rimraf D_db.sqlite* D_test* D_database_name* D_idbtransaction*",
     "copy": "copyup node_modules/core-js-bundle/minified.js node_modules/source-map-support/browser-source-map-support.js node_modules/mocha/mocha.css node_modules/mocha/mocha.js node_modules/chai/chai.js node_modules/sinon/pkg/sinon-no-sourcemaps.js test-support",
+    "fix-permissions": "chmod +x node_modules/npm-run-all/bin/*/index.js",
     "lint": "eslint .",
     "eslint": "npm run lint",
     "sqlite-rebuild": "cd node_modules/sqlite3 && npm i",

package/src/IDBFactory.js

@@ -219,6 +219,57 @@ function getLatestCachedWebSQLDB (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
@@ -257,15 +308,17 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
         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;
     }

package/src/IDBTransaction.js

@@ -180,6 +180,19 @@ 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);