indexeddbshim 17.3.2 → 17.3.4

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));
 }
 
 /**

package/src/nodeSQLiteDatabase.js

@@ -36,16 +36,28 @@ const READ_ONLY_ERROR = new Error(
 //   connection and a newly-opened one during an upgrade. `PRAGMA
 //   busy_timeout` can't safely arbitrate between them here: it blocks the
 //   single JS thread synchronously while it retries, but the lock holder's
-//   own release is itself scheduled via `setTimeout` below, which can never
-//   fire while that retry loop is blocking the same thread -- so instead of
-//   waiting, the second connection's write just fails with "database is
-//   locked". Serialize writes per file path instead, so a second
-//   connection's `BEGIN` waits for the first connection's transaction to
-//   actually finish rather than colliding with it.
+//   own release is itself scheduled via `setImmediate` below, which can
+//   never fire while that retry loop is blocking the same thread -- so
+//   instead of waiting, a second connection's write just fails with
+//   "database is locked".
+//
+// `fileReaders`/`fileWriter` implement a simple (not starvation-proof --
+//   see the release loop below) reader/writer lock per file path instead:
+//   any number of `readonly` transactions may hold the file concurrently,
+//   matching what SQLite itself already natively supports (multiple
+//   readers never need to exclude each other, only a writer needs
+//   exclusivity), while a non-`readonly` transaction still waits for
+//   exclusive access -- no concurrent readers, no concurrent writer. A
+//   simple single-owner mutex (this file's prior implementation) would
+//   otherwise serialize even purely-concurrent-reader scenarios that
+//   never touch a writer at all, for no reason `better-sqlite3`/SQLite
+//   itself requires.
+/** @type {Map<string, Set<{_db: any, _qFilePath: string}>>} */
+const fileReaders = new Map();
 /** @type {Map<string, {_db: any, _qFilePath: string}>} */
-const fileLockOwners = new Map();
-/** @type {Map<string, (() => void)[]>} */
-const fileLockWaiters = new Map();
+const fileWriter = new Map();
+/** @type {Map<string, {isReader: boolean, resume: () => void}[]>} */
+const fileWaiters = new Map();
 const beginRe = /^\s*BEGIN\b/iu;
 const endRe = /^\s*(END|COMMIT|ROLLBACK)\b/iu;
 
@@ -158,14 +170,29 @@ SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
     //   already fully independent -- so there is nothing to serialize.
     const filePath = this._qFilePath === ':memory:' ? null : this._qFilePath;
     if (filePath && queries[0] && beginRe.test(queries[0].sql)) {
-        const owner = fileLockOwners.get(filePath);
-        if (owner && owner !== this) {
-            const waiters = fileLockWaiters.get(filePath) || [];
-            waiters.push(() => this.exec(queries, readOnly, callback));
-            fileLockWaiters.set(filePath, waiters);
+        const activeReaders = fileReaders.get(filePath);
+        const hasActiveReaders = Boolean(activeReaders && activeReaders.size);
+        const activeWriter = fileWriter.get(filePath);
+        const blockedByWriter = Boolean(activeWriter && activeWriter !== this);
+        const blocked = blockedByWriter || (!readOnly && hasActiveReaders);
+        if (blocked) {
+            const waiters = fileWaiters.get(filePath) || [];
+            waiters.push({
+                isReader: readOnly,
+                resume: () => this.exec(queries, readOnly, callback)
+            });
+            fileWaiters.set(filePath, waiters);
             return;
         }
-        fileLockOwners.set(filePath, this);
+        if (readOnly) {
+            if (activeReaders) {
+                activeReaders.add(this);
+            } else {
+                fileReaders.set(filePath, new Set([this]));
+            }
+        } else {
+            fileWriter.set(filePath, this);
+        }
     }
 
     const db = this._db._db;
@@ -204,13 +231,15 @@ SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
             }
         }
     }
-    // A real timer (not `queueMicrotask`) so this yields to the macrotask
-    //   queue: code that synchronously issues a new request from within
-    //   each request's callback (e.g. to keep a transaction alive) would
+    // A real macrotask (not `queueMicrotask`) so this yields properly:
+    //   code that synchronously issues a new request from within each
+    //   request's callback (e.g. to keep a transaction alive) would
     //   otherwise chain microtask to microtask forever, starving out any
     //   `setTimeout`-based code (including IndexedDB's own internal request
-    //   scheduling) that never gets a turn to run.
-    setTimeout(() => {
+    //   scheduling) that never gets a turn to run. `setImmediate` (Node's
+    //   "check" phase) still yields the same way `setTimeout(..., 0)` did,
+    //   but runs sooner in Node's event loop.
+    setImmediate(() => {
         // Release the file lock (if held) and hand it to the next waiting
         //   connection, if any, only once this transaction has genuinely
         //   finished -- and only here, on its own turn, so a resumed
@@ -225,15 +254,52 @@ SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
         //   and never see the matching release, deadlocking every later
         //   connection to the same file.
         if (filePath && queries.some((q) => endRe.test(q.sql))) {
-            fileLockOwners.delete(filePath);
-            const waiters = fileLockWaiters.get(filePath);
-            const nextWaitingExec = waiters && waiters.shift();
-            if (nextWaitingExec) {
-                nextWaitingExec();
+            const activeReaders = fileReaders.get(filePath);
+            if (activeReaders) {
+                activeReaders.delete(this);
+                if (!activeReaders.size) {
+                    fileReaders.delete(filePath);
+                }
+            }
+            if (fileWriter.get(filePath) === this) {
+                fileWriter.delete(filePath);
+            }
+            // Resume as many waiters as the lock now genuinely allows:
+            //   any leading run of readers (concurrent reads are always
+            //   fine), then at most one writer, since a writer needs
+            //   exclusivity -- stop there rather than looking past it.
+            //   Not starvation-proof: a steady stream of arriving readers
+            //   could in principle keep a waiting writer waiting
+            //   indefinitely, but that's an acceptable tradeoff here over
+            //   the added complexity of tracking arrival order across
+            //   reader/writer kinds.
+            const waiters = fileWaiters.get(filePath);
+            if (waiters) {
+                while (waiters.length) {
+                    if (fileWriter.has(filePath)) {
+                        break;
+                    }
+                    const next = waiters[0];
+                    const stillHasReaders = fileReaders.get(filePath);
+                    if (!next.isReader && stillHasReaders && stillHasReaders.size) {
+                        break;
+                    }
+                    waiters.shift();
+                    next.resume();
+                    if (!next.isReader) {
+                        // A writer just took exclusive ownership (inside
+                        //   `resume()`, synchronously, via the acquire
+                        //   logic above) -- nothing else may proceed now.
+                        break;
+                    }
+                }
+                if (!waiters.length) {
+                    fileWaiters.delete(filePath);
+                }
             }
         }
         callback(null, results);
-    }, 0);
+    });
 };
 
 export default SQLiteDatabase;

package/src/nodeWebSQL.js

@@ -40,5 +40,12 @@ function wrappedSQLiteDatabase (name) {
     return db;
 }
 
-const nodeWebSQL = customOpenDatabase(/** @type {SQLiteDatabaseConstructor} */ (/** @type {unknown} */ (wrappedSQLiteDatabase)), {});
+// `concurrentReaders` is off by default in `websql-configurable` itself (to
+//   preserve the WebSQL spec's strict, one-at-a-time transaction ordering
+//   that library's own test suite depends on), but IndexedDBShim only ever
+//   uses it as an internal SQL execution engine -- it doesn't need or expose
+//   that ordering guarantee itself -- so it's safe, and needed, to opt in
+//   here: without it, two same-scope `readonly` IDBTransactions can deadlock
+//   waiting on each other (see `transaction-scheduling-within-database.any.js`).
+const nodeWebSQL = customOpenDatabase(/** @type {SQLiteDatabaseConstructor} */ (/** @type {unknown} */ (wrappedSQLiteDatabase)), {websql: {concurrentReaders: true}});
 export default nodeWebSQL;