indexeddbshim 17.3.3 → 17.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.3.3",
+  "version": "17.3.4",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -172,7 +172,7 @@
     "eventtargeter": "0.12.0",
     "sync-promise-expanded": "^2.0.0",
     "typeson": "10.2.0",
-    "typeson-registry": "14.2.2",
+    "typeson-registry": "14.3.0",
     "websql-configurable": "^3.1.0"
   },
   "devDependencies": {
@@ -214,7 +214,7 @@
     "npm-run-all": "^4.1.5",
     "open-cli": "^9.0.0",
     "rimraf": "^6.1.3",
-    "rollup": "^4.62.5",
+    "rollup": "^4.63.0",
     "rollup-plugin-filesize": "^10.0.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "sinon": "^22.1.0",

package/src/IDBFactory.js

@@ -557,6 +557,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
     const req = IDBOpenDBRequest.__createInstance();
     let calledDbCreateError = false;
+    let isRevertingSysdb = false;
 
     if (CFG.autoName && name === '') {
         // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Necessary?
@@ -585,7 +586,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
      * @returns {boolean}
      */
     function dbCreateError (tx, err) {
-        if (calledDbCreateError) {
+        if (calledDbCreateError || isRevertingSysdb) {
             return false;
         }
         // Defensive cleanup: `pendingVersionChanges.set(name, ...)` (see
@@ -647,46 +648,63 @@ IDBFactory.prototype.open = function (name /* , version */) {
                      */
                     let sysdbFinishedCb = function (systx, err, cb) {
                         if (err) {
-                            try {
-                                systx.executeSql('ROLLBACK', [], cb, cb);
-                            } catch (err) {
-                                // Browser may fail with expired transaction above so
-                                //     no choice but to manually revert
-                                sysdb.transaction(function (systx) {
-                                    /**
-                                     *
-                                     * @param {string} msg
-                                     * @throws {Error}
-                                     * @returns {never}
-                                     */
-                                    function reportError (msg) {
-                                        throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
+                            /**
+                             * @param {any} [errorToShow]
+                             * @returns {void}
+                             */
+                            const manualRevert = function (errorToShow) {
+                                /**
+                                 * @param {string} [msg]
+                                 * @throws {Error}
+                                 * @returns {never}
+                                 */
+                                function reportError (msg) {
+                                    throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
+                                }
+
+                                sysdb.transaction(
+                                    function (systx) {
+                                        // Attempt to revert
+                                        if (oldVersion === 0) {
+                                            systx.executeSql(
+                                                'DELETE FROM dbVersions WHERE "name" = ?',
+                                                [sqlSafeName]
+                                            );
+                                        } else {
+                                            systx.executeSql(
+                                                'UPDATE dbVersions SET "version" = ? WHERE "name" = ?',
+                                                [oldVersion, sqlSafeName]
+                                            );
+                                        }
+                                    },
+                                    function (sqlErr) {
+                                        isRevertingSysdb = false;
+                                        cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                                    },
+                                    function () {
+                                        isRevertingSysdb = false;
+                                        cb(errorToShow || reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                                     }
+                                );
+                            };
 
-                                    // Attempt to revert
-                                    if (oldVersion === 0) {
-                                        systx.executeSql(
-                                            'DELETE FROM dbVersions WHERE "name" = ?',
-                                            [sqlSafeName],
-                                            function () {
-                                                // @ts-expect-error Force to work
-                                                cb(reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
-                                            },
-                                            // @ts-expect-error Force to work
-                                            reportError
-                                        );
-                                    } else {
-                                        systx.executeSql(
-                                            'UPDATE dbVersions SET "version" = ? WHERE "name" = ?',
-                                            [
-                                                oldVersion, sqlSafeName
-                                            ],
-                                            cb,
-                                            // @ts-expect-error Force to work
-                                            reportError
-                                        );
+                            try {
+                                systx.executeSql(
+                                    'ROLLBACK',
+                                    [],
+                                    function () {
+                                        cb(); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                                    },
+                                    function (tx, sqlErr) {
+                                        // Browser/Node may fail with expired transaction, so manually revert
+                                        manualRevert(sqlErr);
+                                        return false;
                                     }
-                                });
+                                );
+                            } catch (e) {
+                                // Browser may fail with expired transaction above so
+                                //     no choice but to manually revert
+                                manualRevert(e);
                             }
                             return;
                         }
@@ -790,6 +808,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
                             // eslint-disable-next-line camelcase -- Clear API
                             req.transaction.on__preabort = function () {
+                                isRevertingSysdb = true;
                                 pendingVersionChanges.delete(name);
                                 connection.__upgradeTransaction = null;
                                 // We ensure any cache is deleted before any request error events fire and try to reopen
@@ -808,6 +827,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                 req.__done = false;
 
                                 connection.close();
+                                isRevertingSysdb = true;
                                 setTimeout(() => {
                                     const err = createDOMException('AbortError', 'The upgrade transaction was aborted.');
                                     sysdbFinishedCb(systx, err, function (reportError) {
@@ -876,7 +896,36 @@ IDBFactory.prototype.open = function (name /* , version */) {
                         }
                         sysdbFinishedCb = function (systx, err, cb) {
                             if (err) {
-                                rollback(err, cb);
+                                rollback(err,
+                                    /**
+                                     * @param {Error} [reportError]
+                                     * @returns {void}
+                                     */
+                                    function (reportError) {
+                                        sysdb.transaction(
+                                            function (systx) {
+                                                if (oldVersion === 0) {
+                                                    systx.executeSql(
+                                                        'DELETE FROM dbVersions WHERE "name" = ?',
+                                                        [sqlSafeName]
+                                                    );
+                                                } else {
+                                                    systx.executeSql(
+                                                        'UPDATE dbVersions SET "version" = ? WHERE "name" = ?',
+                                                        [oldVersion, sqlSafeName]
+                                                    );
+                                                }
+                                            },
+                                            function (sqlErr) {
+                                                isRevertingSysdb = false;
+                                                cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                                            },
+                                            function () {
+                                                isRevertingSysdb = false;
+                                                cb(reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                                            }
+                                        );
+                                    });
                             } else {
                                 commit(cb);
                             }

package/src/IDBTransaction.js

@@ -8,6 +8,7 @@ import IDBObjectStore from './IDBObjectStore.js';
 import CFG from './CFG.js';
 
 let uniqueID = 0;
+const activeTransactions = new Set();
 const listeners = ['onabort', 'oncomplete', 'onerror'];
 const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'error'];
 
@@ -137,6 +138,7 @@ IDBTransaction.__createInstance = function (db, storeNames, mode, durability = '
         me.__mode = mode;
         me.__durability = durability;
         me.__db = db;
+        activeTransactions.add(me);
         me.__error = null;
         // @ts-expect-error Part of `ShimEventTarget`
         me.__setOptions({
@@ -641,6 +643,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 me.__errored = true;
                 throw e;
             } finally {
+                activeTransactions.delete(me);
                 me.__storeHandles = {};
             }
         }
@@ -855,6 +858,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         });
     }
     me.__active = false; // Setting here and in requestsFinished for https://github.com/w3c/IndexedDB/issues/87
+    activeTransactions.delete(me);
 
     if (err !== null) {
         me.__error = err;
@@ -1064,7 +1068,7 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
  * @returns {void}
  */
 IDBTransaction.__assertActive = function (tx) {
-    if (!tx || !tx.__active || tx.__committed) {
+    if (!tx || !tx.__active || !tx.__handlerActive || tx.__committed) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
 };
@@ -1095,4 +1099,6 @@ Object.defineProperty(IDBTransaction, 'prototype', {
 });
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
+IDBTransaction.activeTransactions = activeTransactions;
+
 export default IDBTransaction;

package/src/Key.js

@@ -1,3 +1,22 @@
+/**
+ * @param {unknown[]} arr
+ * @param {number} index
+ * @param {unknown} val
+ * @returns {void}
+ */
+const setArrayValue = (arr, index, val) => {
+    if (Reflect.has(Array.prototype, index)) {
+        Object.defineProperty(arr, index, {value: val, enumerable: true, writable: true, configurable: true});
+    } else {
+        arr[index] = val;
+    }
+};
+/**
+ * @param {unknown[]} arr
+ * @param {unknown} val
+ * @returns {void}
+ */
+const safePush = (arr, val) => setArrayValue(arr, arr.length, val);
 import {createDOMException} from './DOMException.js';
 import * as util from './util.js';
 import cmp from './cmp.js';
@@ -281,12 +300,13 @@ const types = {
          * @returns {string}
          */
         encode (key) {
+            /** @type {(string|null)[]} */
             const encoded = [];
             for (const [i, item] of key.entries()) {
                 const encodedItem = encode(item, true); // encode the array item
-                encoded[i] = encodedItem;
+                setArrayValue(encoded, i, encodedItem);
             }
-            encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
+            safePush(encoded, keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
             let encodedKey = JSON.stringify(encoded);
             if (CFG.escapeNULForSQLiteStatements === false) {
                 encodedKey = encodedKey.replaceAll(String.raw`\u0000`, '\0');
@@ -307,7 +327,7 @@ const types = {
             for (let i = 0; i < decoded.length; i++) {
                 const item = decoded[i];
                 const decodedItem = decode(item, true); // decode the item
-                decoded[i] = decodedItem;
+                setArrayValue(decoded, i, decodedItem);
             }
             return decoded;
         }
@@ -577,7 +597,7 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
     } case 'array': { // May throw (from binary)
         const arr = /** @type {Array<any>} */ (input);
         const len = arr.length;
-        seen.push(input);
+        safePush(seen, input);
 
         /** @type {(KeyValueObject|Value)[]} */
         const keys = [];
@@ -598,7 +618,7 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
                     (!fullKeys && keys.every((k) => cmp(k, key.value) !== 0)) ||
                     (fullKeys && keys.every((k) => cmp(k, key) !== 0))
                 ) {
-                    keys.push(fullKeys ? key : key.value);
+                    safePush(keys, fullKeys ? key : key.value);
                 }
             } catch (err) {
                 if (!multiEntry) {
@@ -732,7 +752,7 @@ function evaluateKeyPathOnValueToDecodedValue (value, keyPath, multiEntry, fullK
             if (key.failure) {
                 return true;
             }
-            result.push(key.value);
+            safePush(result, key.value);
             return false;
         })
             ? {failure: true}
@@ -793,11 +813,11 @@ function injectKeyIntoValueUsingKeyPath (value, key, keyPath) {
     identifiers.forEach((identifier) => {
         const hop = Object.hasOwn(value, identifier);
         if (!hop) {
-            value[identifier] = {};
+            Object.defineProperty(value, identifier, {value: {}, enumerable: true, writable: true, configurable: true});
         }
         value = value[identifier];
     });
-    value[/** @type {string} */ (last)] = key; // key is already a `keyValue` in our processing so no need to convert
+    Object.defineProperty(value, /** @type {string} */ (last), {value: key, enumerable: true, writable: true, configurable: true}); // key is already a `keyValue` in our processing so no need to convert
 }
 
 /**
@@ -883,6 +903,7 @@ function isMultiEntryMatch (encodedEntry, encodedKey) {
  * @returns {Key[]}
  */
 function findMultiEntryMatches (keyEntry, range) {
+    /** @type {unknown[]} */
     const matches = [];
 
     if (Array.isArray(keyEntry)) {
@@ -896,18 +917,18 @@ function findMultiEntryMatches (keyEntry, range) {
                 } else {
                     const nested = findMultiEntryMatches(key, range);
                     if (nested.length > 0) {
-                        matches.push(key);
+                        safePush(matches, key);
                     }
                     continue;
                 }
             }
 
             if (util.isNullish(range) || isKeyInRange(key, range, true)) {
-                matches.push(key);
+                safePush(matches, key);
             }
         }
     } else if (util.isNullish(range) || isKeyInRange(keyEntry, range, true)) {
-        matches.push(keyEntry);
+        safePush(matches, keyEntry);
     }
     return matches;
 }
@@ -924,12 +945,13 @@ function convertKeyToValue (key) {
     case 'number': case 'string': {
         return value;
     } case 'array': {
+        /** @type {ValueType[]} */
         const array = [];
         const len = value.length;
         let index = 0;
         while (index < len) {
             const entry = convertKeyToValue(value[index]);
-            array[index] = entry;
+            setArrayValue(array, index, entry);
             index++;
         }
         return array;

package/src/Sca.js

@@ -1,12 +1,62 @@
 import {
-    Typeson, hasConstructorOf, structuredCloningThrowing
+    Typeson, hasConstructorOf, structuredCloningForStorage
 } from 'typeson-registry';
 
 import {createDOMException, ShimDOMException} from './DOMException.js';
 
 // See: https://stackoverflow.com/questions/42170826/categories-for-rejection-by-the-structured-cloning-algorithm
 
-let typeson = new Typeson().register(structuredCloningThrowing);
+// Although typeson-registry already has a FileList type in its structured cloning presets,
+//   we need to override it so it works with our tests
+
+const specSet = structuredCloningForStorage
+    .flatMap((preset) => (Array.isArray(preset) ? preset : [preset]))
+    .find((preset) => preset && !Array.isArray(preset) && 'filelist' in preset);
+
+const origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet
+    ? specSet.filelist
+    : undefined;
+
+const origTest = origFileList && typeof origFileList === 'object' && 'test' in origFileList && typeof origFileList.test === 'function'
+    ? origFileList.test
+    : undefined;
+
+const origRevive = origFileList && typeof origFileList === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function'
+    ? origFileList.revive
+    : undefined;
+
+const customFileList = origFileList
+    ? {
+        ...origFileList,
+        /**
+         * @param {unknown} x
+         * @param {import('typeson').StateObject} state
+         * @returns {boolean}
+         */
+        test (x, state) {
+            if (typeof FileList !== 'undefined') {
+                return x instanceof FileList;
+            }
+            return typeof origTest === 'function' ? origTest(x, state) : false;
+        },
+        /**
+         * @param {unknown} x
+         * @param {import('typeson').StateObject} state
+         * @returns {unknown}
+         */
+        revive (x, state) {
+            if (typeof FileList !== 'undefined') {
+                return Reflect.construct(FileList, [x]);
+            }
+            return typeof origRevive === 'function' ? origRevive(x, state) : undefined;
+        }
+    }
+    : undefined;
+
+let typeson = new Typeson().register([
+    structuredCloningForStorage,
+    customFileList ? {filelist: customFileList} : {}
+]);
 
 /**
  * @param {(preset: import('typeson-registry').Preset) =>
@@ -15,7 +65,7 @@ let typeson = new Typeson().register(structuredCloningThrowing);
  */
 function register (func) {
     // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Should be one-time cache
-    typeson = new Typeson().register(func(structuredCloningThrowing));
+    typeson = new Typeson().register(func(structuredCloningForStorage));
 }
 
 /**