indexeddbshim 17.3.1 → 17.3.3

package/dist/nodeSQLiteDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeSQLiteDatabase.d.ts","sourceRoot":"","sources":["../src/nodeSQLiteDatabase.js"],"names":[],"mappings":";iCAyBa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI;+BAIvC,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAC,SAAS;AAsB9C;;;;;;GAMG;AACH;SAHgB,GAAG;gBAAc,MAAM;SAF5B,MAAM,SACN;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAC,GAEjF,IAAI,CAmEhB;;IAxED;;;;;;OAMG;IACH;aAHgB,GAAG;oBAAc,MAAM;aAF5B,MAAM,SACN;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAC,EAqE7F;IAhEG,mBAAsB;IAkBtB,SA6CE;IAyBN;;;;;OAKG;IACH,cALW;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAC,EAAE,YAChC,OAAO,YACP,CAAC,GAAG,EAAE,KAAK,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,GACjD,IAAI,CAqFhB;;AA1OD;;GAEG;AACH;IACI;;;;;OAKG;IACH,mBALW,KAAK,GAAC,IAAI,GAAC,SAAS,aACpB,MAAM,GAAC,SAAS,iBAChB,MAAM,SACN,MAAM,EAAE,EAOlB;IAJG,gCAAkB;IAClB,6BAAwB;IACxB,iCAAgC;IAChC,2BAAgB;CAEvB"}
+{"version":3,"file":"nodeSQLiteDatabase.d.ts","sourceRoot":"","sources":["../src/nodeSQLiteDatabase.js"],"names":[],"mappings":";iCAyBa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI;+BAIvC,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAC,SAAS;AAkC9C;;;;;;GAMG;AACH;SAHgB,GAAG;gBAAc,MAAM;SAF5B,MAAM,SACN;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAC,GAEjF,IAAI,CAmEhB;;IAxED;;;;;;OAMG;IACH;aAHgB,GAAG;oBAAc,MAAM;aAF5B,MAAM,SACN;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAC,EAqE7F;IAhEG,mBAAsB;IAkBtB,SA6CE;IAyBN;;;;;OAKG;IACH,cALW;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAC,EAAE,YAChC,OAAO,YACP,CAAC,GAAG,EAAE,KAAK,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,GACjD,IAAI,CA2IhB;;AA5SD;;GAEG;AACH;IACI;;;;;OAKG;IACH,mBALW,KAAK,GAAC,IAAI,GAAC,SAAS,aACpB,MAAM,GAAC,SAAS,iBAChB,MAAM,SACN,MAAM,EAAE,EAOlB;IAJG,gCAAkB;IAClB,6BAAwB;IACxB,iCAAgC;IAChC,2BAAgB;CAEvB"}

package/dist/nodeWebSQL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeWebSQL.d.ts","sourceRoot":"","sources":["../src/nodeWebSQL.js"],"names":[],"mappings":";qCAKa;IACR,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,CAAA,OAAO,cAAc,EAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;CACjD;;;;;;;;;;;wCAYS,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,sBAAsB;AAsBrE,qHAAqI;2BAzC1G,yBAAyB"}
+{"version":3,"file":"nodeWebSQL.d.ts","sourceRoot":"","sources":["../src/nodeWebSQL.js"],"names":[],"mappings":";qCAKa;IACR,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,CAAA,OAAO,cAAc,EAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;CACjD;;;;;;;;;;;wCAYS,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,sBAAsB;AA6BrE,qHAAsK;2BAhD3I,yBAAyB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.3.1",
+  "version": "17.3.3",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -102,6 +102,7 @@
     "w3c-test": "run-s clean-w3c test-and-start:w3c",
     "w3c-good-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js good",
     "w3c-bad-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js bad",
+    "w3c-good-worker-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js good-worker",
     "w3c-good": "run-s w3c-build w3c-good-only clean-w3c",
     "w3c-bad": "run-s w3c-build w3c-bad-only clean-w3c",
     "w3c-good-test": "run-s w3c-good-only clean-w3c",
@@ -171,8 +172,8 @@
     "eventtargeter": "0.12.0",
     "sync-promise-expanded": "^2.0.0",
     "typeson": "10.2.0",
-    "typeson-registry": "14.2.1",
-    "websql-configurable": "^3.0.6"
+    "typeson-registry": "14.2.2",
+    "websql-configurable": "^3.1.0"
   },
   "devDependencies": {
     "@babel/core": "^8.0.1",

package/src/IDBCursor.js

@@ -260,9 +260,33 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
         // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
         sqlValues.push(/** @type {string} */ (Key.encode(key)));
     } else if (continueCall && me.__key !== undefined) {
-        sql.push('AND', quotedKeyColumnName, op + ' ?');
         // Key.convertValueToKey(me.__key); // Already checked when stored
-        sqlValues.push(/** @type {string} */ (Key.encode(me.__key)));
+        if (!me.__unique && me.__keyColumnName !== 'key' && me.__primaryKey !== undefined) {
+            // A plain `continue()` on a non-unique index cursor must find
+            //   the next record strictly after the (key, primaryKey) pair
+            //   this cursor last returned -- a scalar `key > lastKey` alone
+            //   would wrongly exclude a *different*, not-yet-visited record
+            //   that's still tied on key with the last one (e.g. another
+            //   record that always had that same indexed value), and would
+            //   also wrongly re-admit the *same* record forever if a
+            //   same-transaction `update()` bumped its own key back above
+            //   the threshold, since a scalar comparison can't distinguish
+            //   "some other record newly tied" from "this record moved
+            //   past its own last position." Comparing the full tuple (via
+            //   this OR) against both key and primary key resolves both.
+            sql.push(
+                'AND (', quotedKeyColumnName, op, '?',
+                'OR (', quotedKeyColumnName, '= ?', 'AND', quotedKey, op, '?))'
+            );
+            sqlValues.push(
+                /** @type {string} */ (Key.encode(me.__key)),
+                /** @type {string} */ (Key.encode(me.__key)),
+                /** @type {string} */ (Key.encode(me.__primaryKey))
+            );
+        } else {
+            sql.push('AND', quotedKeyColumnName, op + ' ?');
+            sqlValues.push(/** @type {string} */ (Key.encode(me.__key)));
+        }
     }
 
     if (!me.__count) {
@@ -912,9 +936,15 @@ IDBCursor.prototype.update = function (valueToUpdate) {
      * @returns {void}
      */
     function addToQueue (clonedValue) {
-        // We set the `invalidateCache` argument to `false` since the old value shouldn't be accessed
+        // `invalidateCache: true` so any cursor on this store (including
+        //   this one) drops its prefetched row batch, forcing its next
+        //   `continue()` to re-query live rather than serve rows snapshotted
+        //   before this update -- needed for the compound-tuple
+        //   continuation logic in `__findBasic` to see this update's
+        //   effect on ordering (see "Modify records during cursor
+        //   iteration" in idbcursor_update_index.any.js).
         // @ts-ignore -- API (not erring in TS 6)
-        IDBObjectStore.__storingRecordObjectStore(request, me.__store, false, clonedValue, false, key);
+        IDBObjectStore.__storingRecordObjectStore(request, me.__store, true, clonedValue, false, key);
     }
     if (me.__store.keyPath !== null) {
         const [evaluatedKey, clonedValue] = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true);

package/src/IDBFactory.js

@@ -156,7 +156,29 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
             return new SyncPromise(function (resolve) {
                 setTimeout(() => {
                     entry.dispatchEvent(e); // No need to catch errors
-                    resolve(undefined);
+                    // Unlike a native `Promise`, `SyncPromise#then` chains
+                    //   synchronously off `resolve()` (verified directly:
+                    //   `SyncPromise.resolve().then(cb)` runs `cb` before
+                    //   even the calling code below it finishes) -- so
+                    //   resolving immediately here would let the
+                    //   `connectionsClosed()` check below run before a
+                    //   same-task-but-microtask-later continuation of a
+                    //   `versionchange` listener above (e.g. an `await`-
+                    //   based one that then calls `db.close()`, as in
+                    //   `transaction-lifetime.any.js`) ever gets a turn,
+                    //   incorrectly firing `blocked` even though the
+                    //   connection was about to close in time. Give real
+                    //   microtask-deferred continuations a small, bounded
+                    //   number of turns first -- same pattern as
+                    //   `IDBTransaction.js`'s `checkQueueEntry`.
+                    let attemptsLeft = 10;
+                    (function wait () {
+                        if (attemptsLeft-- <= 0) {
+                            resolve(undefined);
+                            return;
+                        }
+                        queueMicrotask(wait);
+                    }());
                 }, 0);
             });
         });
@@ -214,6 +236,23 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
  */
 const websqlDBCache = {};
 
+/**
+ * Tracks databases with a creation/upgrade currently in flight but not yet
+ *   committed or aborted -- keyed by (unescaped) database name. The
+ *   `dbVersions` row in `sysdb` these entries shadow is written *before*
+ *   `upgradeneeded` is even dispatched to user code (as the success
+ *   callback of that very `INSERT`/`UPDATE`), on the same shared `sysdb`
+ *   connection `databases()` itself reads from -- so, absent this, a
+ *   `databases()` call made while an upgrade is still pending would see
+ *   the new row (or new version) immediately, rather than only once the
+ *   corresponding `versionchange` transaction has genuinely committed, as
+ *   required by `get-databases.any.js`'s "doesn't pick up changes that
+ *   haven't committed" test. `IDBFactory.prototype.databases` filters
+ *   its SQL results against this map.
+ * @type {Map<string, {oldVersion: Integer, newVersion: Integer}>}
+ */
+const pendingVersionChanges = new Map();
+
 /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
 let sysdb;
 let nameCounter = 0;
@@ -549,6 +588,19 @@ IDBFactory.prototype.open = function (name /* , version */) {
         if (calledDbCreateError) {
             return false;
         }
+        // Defensive cleanup: `pendingVersionChanges.set(name, ...)` (see
+        //   below) runs *before* the `dbVersions` `INSERT`/`UPDATE` it
+        //   guards is even attempted, but only `versionSet`'s own
+        //   `on__beforecomplete`/`on__preabort` handlers ever clear it --
+        //   and `versionSet` never runs at all if that `INSERT`/`UPDATE`,
+        //   or an earlier step in this same `open()` flow, fails first.
+        //   Without this, such a failure would leave the entry orphaned
+        //   forever, silently corrupting `databases()` for any *other*,
+        //   unrelated later `open()` call that happens to reuse the same
+        //   database name (common in WPT tests, e.g. generic names like
+        //   "DB1"/"TestDatabase" reused across different test files in
+        //   the same process). A no-op if no entry was ever set.
+        pendingVersionChanges.delete(name);
         const er = err ? webSQLErrback(err) : /** @type {Error} */ (tx);
         calledDbCreateError = true;
         // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
@@ -668,22 +720,43 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                     //   open/close the transaction's active-handler window itself.
                                     req.transaction.__handlerActive = true;
                                     req.dispatchEvent(e);
-                                    // Give any same-tick microtask scheduled from within the
+                                    // Give any microtask-scheduled continuation of the
                                     //   `upgradeneeded` handler (e.g. a plain
-                                    //   `Promise.resolve().then(...)`) a chance to run -- and still
-                                    //   observe the transaction as active -- before we deactivate it
-                                    //   again, per https://github.com/w3c/IndexedDB/issues/87. Only
-                                    //   the flag reset itself is deferred here -- unlike
-                                    //   `IDBTransaction.js`'s `advanceAfterDispatch`, `finished()`
-                                    //   (this transaction's own queue-advancement/completion signal)
-                                    //   still runs synchronously, at exactly its previous timing: an
-                                    //   earlier attempt at deferring `finished()` too raced against
-                                    //   unrelated test setup that assumed a freshly deleted/created
-                                    //   database's upgrade transaction had already fully completed by
-                                    //   the time this function returns.
-                                    queueMicrotask(() => {
-                                        req.transaction.__handlerActive = false;
-                                    });
+                                    //   `Promise.resolve().then(...)`, or an `await`-based
+                                    //   continuation of a promise resolved from within the handler,
+                                    //   such as testharness.js's own `EventWatcher`) a chance to
+                                    //   run -- and still observe the transaction as active -- before
+                                    //   we deactivate it again, per
+                                    //   https://github.com/w3c/IndexedDB/issues/87. A single deferred
+                                    //   tick isn't always enough: an `await`-based continuation can
+                                    //   take more than one microtask turn to resume (e.g.
+                                    //   `transaction-lifetime.any.js`'s `EventWatcher`-based
+                                    //   `await eventWatcher.wait_for('upgradeneeded')`), so retry a
+                                    //   small, bounded number of times first -- same pattern as
+                                    //   `IDBTransaction.js`'s `checkQueueEntry` -- rather than
+                                    //   resetting after only one. Only the flag reset itself is
+                                    //   deferred here -- unlike `IDBTransaction.js`'s
+                                    //   `advanceAfterDispatch`, `finished()` (this transaction's own
+                                    //   queue-advancement/completion signal) still runs
+                                    //   synchronously, at exactly its previous timing: an earlier
+                                    //   attempt at deferring `finished()` too raced against unrelated
+                                    //   test setup that assumed a freshly deleted/created database's
+                                    //   upgrade transaction had already fully completed by the time
+                                    //   this function returns.
+                                    /**
+                                     * @param {Integer} attemptsLeft
+                                     * @returns {void}
+                                     */
+                                    function deferHandlerActiveReset (attemptsLeft) {
+                                        if (attemptsLeft <= 0) {
+                                            req.transaction.__handlerActive = false;
+                                            return;
+                                        }
+                                        queueMicrotask(() => {
+                                            deferHandlerActiveReset(attemptsLeft - 1);
+                                        });
+                                    }
+                                    deferHandlerActiveReset(10);
 
                                     if (e.__legacyOutputDidListenersThrowError) {
                                         logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', /** @type {Error} */ (e.__legacyOutputDidListenersThrowError)); // We do nothing else with this error as per spec
@@ -701,6 +774,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                  * @returns {void}
                                  */
                                 function (ev) {
+                                    pendingVersionChanges.delete(name);
                                     connection.__upgradeTransaction = null;
                                     /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */ (
                                         req.__result
@@ -716,6 +790,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
                             // eslint-disable-next-line camelcase -- Clear API
                             req.transaction.on__preabort = function () {
+                                pendingVersionChanges.delete(name);
                                 connection.__upgradeTransaction = null;
                                 // We ensure any cache is deleted before any request error events fire and try to reopen
                                 if (useDatabaseCache) {
@@ -789,6 +864,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                             };
                         }
 
+                        pendingVersionChanges.set(name, {oldVersion, newVersion: version});
                         if (oldVersion === 0) {
                             systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
                         } else {
@@ -1102,6 +1178,15 @@ IDBFactory.prototype.cmp = function (key1, key2) {
 IDBFactory.prototype.databases = function () {
     const me = this;
     let calledDbCreateError = false;
+    // Snapshotted *now*, synchronously, at call time -- not read later
+    // from inside the SQL query's callback below, which runs on a
+    //   deferred macrotask (see `nodeSQLiteDatabase.js`'s `exec`) and so
+    //   could otherwise race against (and lose to) an in-flight upgrade's
+    //   own commit/abort handler clearing its `pendingVersionChanges`
+    //   entry in the meantime -- which would make this method incorrectly
+    //   reflect a since-committed change that hadn't committed yet when
+    //   it was actually called.
+    const pendingVersionChangesSnapshot = new Map(pendingVersionChanges);
     return new Promise(function (resolve, reject) { // eslint-disable-line promise/avoid-new -- Own polyfill
         if (!(me instanceof IDBFactory)) {
             throw new TypeError('Illegal invocation');
@@ -1129,11 +1214,24 @@ IDBFactory.prototype.databases = function () {
                 sysReadTx.executeSql('SELECT "name", "version" FROM dbVersions', [], function (sysReadTx, data) {
                     const dbNames = [];
                     for (let i = 0; i < data.rows.length; i++) {
-                        const {name, version} = /** @type {{name: string, version: Integer}} */ (data.rows.item(i));
-                        dbNames.push({
-                            name: util.unescapeSQLiteResponse(name),
-                            version
-                        });
+                        const {name: encodedName, version} = /** @type {{name: string, version: Integer}} */ (data.rows.item(i));
+                        const name = util.unescapeSQLiteResponse(encodedName);
+                        // A row for a database whose creation/upgrade hasn't
+                        //   committed yet (see `pendingVersionChanges`) must
+                        //   not reflect that in-flight change: a brand new
+                        //   database (`oldVersion === 0`) isn't reported at
+                        //   all until its creation commits, and an existing
+                        //   database being upgraded is still reported, but
+                        //   with its pre-upgrade version.
+                        const pending = pendingVersionChangesSnapshot.get(name);
+                        if (pending) {
+                            if (pending.oldVersion === 0) {
+                                continue;
+                            }
+                            dbNames.push({name, version: pending.oldVersion});
+                            continue;
+                        }
+                        dbNames.push({name, version});
                     }
                     resolve(dbNames);
                 }, dbGetDatabaseNamesError);

package/src/IDBObjectStore.js

@@ -6,6 +6,7 @@ import DOMStringList from './DOMStringList.js';
 import * as util from './util.js';
 import * as Key from './Key.js';
 import {executeFetchIndexData, buildFetchIndexDataSQL, IDBIndex} from './IDBIndex.js';
+import cmp from './cmp.js';
 import IDBTransaction from './IDBTransaction.js';
 import * as Sca from './Sca.js';
 import CFG from './CFG.js';
@@ -69,6 +70,11 @@ const IDBObjectStoreAlias = IDBObjectStore;
  *     success: (key: import('./Key.js').Key, cn?: Integer) => void,
  *     failCb: import('./Key.js').SQLFailureCallback
  *   ) => void,
+ *   __checkIndexConstraints: (
+ *     tx: WebSQLTransaction,
+ *     value: import('./Key.js').Value,
+ *     excludeKey: import('./Key.js').Key|Integer|undefined
+ *   ) => SyncPromise,
  *   __insertData: (
  *     tx: WebSQLTransaction,
  *     encoded: string,
@@ -518,6 +524,77 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
     }
 };
 
+/**
+ * Validates `value`'s unique index entries against the table's *current*
+ *   state without mutating anything -- used by `__storingRecordObjectStore`
+ *   to check a `put()`'s constraints *before* `__overwrite` deletes the
+ *   existing row for that key, so a rejected `put()` can't end up losing
+ *   the record it was trying to replace (see
+ *   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+ *   `excludeKey`, when given, treats a conflicting record as a non-conflict
+ *   if it's the very record being overwritten (its own current entry would
+ *   otherwise self-conflict on every no-op `put()` of an unchanged value).
+ *   `__insertData` below still runs its own (now redundant, but harmless --
+ *   the old row is gone by then) equivalent check as its first step; this
+ *   isn't merged into it because `__insertData` also performs the actual
+ *   `INSERT`, which cannot safely run before `__overwrite`'s `DELETE` when
+ *   overwriting an existing key.
+ * @param {WebSQLTransaction} tx
+ * @param {import('./Key.js').Value} value
+ * @param {import('./Key.js').Key|Integer|undefined} excludeKey
+ * @this {IDBObjectStoreFull}
+ * @returns {SyncPromise}
+ */
+IDBObjectStore.prototype.__checkIndexConstraints = function (tx, value, excludeKey) {
+    const me = this;
+    const indexPromises = Object.keys(me.__indexes).map((indexName) => {
+        return new SyncPromise((resolve, reject) => {
+            const index = me.__indexes[indexName];
+            if (index.__pendingCreate || index.__deleted || !index.unique) {
+                resolve(undefined);
+                return;
+            }
+            /**
+             * @type {import('./Key.js').KeyValueObject|
+             *   import('./Key.js').KeyPathEvaluateValue}
+             */
+            let indexKey;
+            try {
+                indexKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry);
+                if (
+                    ('invalid' in indexKey && indexKey.invalid) ||
+                    ('failure' in indexKey && indexKey.failure)
+                ) {
+                    throw new Error('Go to catch');
+                }
+            } catch (err) {
+                resolve(undefined);
+                return;
+            }
+            indexKey = indexKey.value;
+            if (indexKey === undefined) {
+                resolve(undefined);
+                return;
+            }
+            const multiCheck = index.multiEntry && Array.isArray(indexKey);
+            const fetchArgs = buildFetchIndexDataSQL(true, index, indexKey, 'key', multiCheck);
+            executeFetchIndexData(null, ...fetchArgs, tx, null, function success (key) {
+                if (key === undefined || (excludeKey !== undefined && cmp(key, excludeKey) === 0)) {
+                    resolve(undefined);
+                    return;
+                }
+                reject(createDOMException(
+                    'ConstraintError',
+                    'Index already contains a record equal to ' +
+                        (multiCheck ? 'one of the subkeys of' : '') +
+                        '`indexKey`'
+                ));
+            }, reject);
+        });
+    });
+    return SyncPromise.all(indexPromises);
+};
+
 /**
  *
  * @param {WebSQLTransaction} tx
@@ -794,7 +871,32 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
                     }, error);
                 }
                 if (!noOverwrite) {
-                    store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+                    // Validate unique index constraints *before* `__overwrite`
+                    //   deletes the existing row at this key -- otherwise a
+                    //   `put()` that ends up rejected still permanently loses
+                    //   the record it was trying to replace (see
+                    //   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+                    store.__checkIndexConstraints(tx, value, clonedKeyOrCurrentNumber).then(() => {
+                        store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+                        return undefined;
+                    /**
+                     * @param {Error|DOMException} err
+                     * @returns {null}
+                     */
+                    }).catch(function (err) {
+                        /**
+                         * @returns {void}
+                         */
+                        function fail () {
+                            error(err);
+                        }
+                        if (typeof oldCn === 'number') {
+                            Key.assignCurrentNumber(tx, store, oldCn, fail, fail);
+                            return null;
+                        }
+                        fail();
+                        return null;
+                    });
                     return;
                 }
                 insert(tx);

package/src/IDBRecord.js

@@ -77,6 +77,14 @@ readonlyProperties.forEach((prop) => {
          * @returns {import('./Key.js').Key|import('./Key.js').Value}
          */
         get [prop] () {
+            // This is defined on the *shared* prototype (see above), so,
+            //   unlike a per-instance getter, it's reachable by calling it
+            //   directly on `IDBRecord.prototype` itself (not a real
+            //   instance) -- WebIDL requires that to throw.
+            if (!(this instanceof IDBRecordAlias)) {
+                throw new TypeError('Illegal invocation');
+            }
+            // @ts-ignore `this` is a real instance past the check above (not an issue in TS7)
             return this['__' + prop];
         }
     };

package/src/IDBTransaction.js

@@ -860,9 +860,15 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         me.__error = err;
     }
 
-    if (me.__requestsFinished) {
+    if (me.__requestsFinished && err !== null) {
         // The transaction has already completed, so we can't call "onerror" or "onabort".
-        // So throw the error instead.
+        // So throw the error instead. `err` is only ever `null` here via
+        //   `IDBTransaction.prototype.abort`'s own `__abortTransaction(null)`
+        //   call, which now checks `__requestsFinished` itself first and
+        //   throws `InvalidStateError` synchronously before ever reaching
+        //   this point -- so this guard is just defense in depth against
+        //   `err` somehow being `null` some other way, not something this
+        //   path should see in practice.
         setTimeout(() => {
             throw err;
         }, 0);
@@ -970,6 +976,14 @@ IDBTransaction.prototype.abort = function () {
     if (me.__committed) {
         throw createDOMException('InvalidStateError', 'The transaction has already been committed');
     }
+    if (me.__requestsFinished) {
+        // All requests have already finished and the transaction is
+        //   auto-committing (the async SQL commit round trip just hasn't
+        //   resolved yet) -- too late to abort per spec, even though
+        //   `__committed` itself isn't set until that round trip actually
+        //   finishes.
+        throw createDOMException('InvalidStateError', 'The transaction is already committing');
+    }
     me.__abortTransaction(null);
 };
 

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;