indexeddbshim 17.2.0 → 17.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.2.0",
+  "version": "17.2.2",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -21,8 +21,8 @@
       "web-platform-tests/**",
       "coverage",
       "ignore",
-      ".eslintrc.js",
-      ".mocharc.cjs",
+      "eslint.config.js",
+      ".mocharc.js",
       "tests-mocha/**",
       "tests-polyfill/**",
       "test-support/**"
@@ -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",
@@ -210,7 +211,6 @@
     "rollup-plugin-node-polyfills": "^0.2.1",
     "sinon": "^22.1.0",
     "source-map-support": "0.5.21",
-    "sourcemap-transformer": "git+https://github.com/brettz9/sourcemap-transformer.git",
     "typescript": "^6.0.3",
     "w3c-blob": "0.0.1",
     "ws": "^8.21.3"

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;
     }
@@ -856,9 +909,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;
@@ -867,7 +928,6 @@ IDBFactory.prototype.deleteDatabase = function (name) {
             // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
             const e = createEvent('error', er, {bubbles: true, cancelable: true});
             req.dispatchEvent(e);
-            calledDBError = true;
         });
         return false;
     }

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);