indexeddbshim 17.2.2 → 17.3.0

package/src/IDBCursor.js

@@ -9,11 +9,18 @@ import * as Key from './Key.js';
 import * as Sca from './Sca.js';
 import {IDBIndex} from './IDBIndex.js';
 import CFG from './CFG.js';
+import IDBRecord from './IDBRecord.js';
+
+const cursorDirections = ['next', 'prev', 'nextunique', 'prevunique'];
 
 /**
  * @typedef {number} Integer
  */
 
+/**
+ * @typedef {import('websql-configurable/lib/websql/WebSQLTransaction.js').default} WebSQLTransaction
+ */
+
 /**
  * @typedef {IDBCursor & {
  *   primaryKey: import('./Key.js').Key,
@@ -49,13 +56,49 @@ import CFG from './CFG.js';
  *   __continuationKey: import('./Key.js').Key|undefined,
  *   __continuationPrimaryKey: import('./Key.js').Key|undefined,
  *   __multiEntryExhausted: boolean,
- *   __invalidateCache: () => void
+ *   __invalidateCache: () => void,
+ *   __gotValue: boolean,
+ *   __find: (...args: any[]) => void,
+ *   __findBasic: (
+ *     key: import('./Key.js').Key|undefined,
+ *     primaryKey: import('./Key.js').Key|undefined,
+ *     tx: WebSQLTransaction,
+ *     success: KeySuccess,
+ *     error: FindError,
+ *     recordsToLoad: Integer|undefined
+ *   ) => void,
+ *   __findMultiEntry: (
+ *     key: import('./Key.js').Key|undefined,
+ *     primaryKey: import('./Key.js').Key|undefined,
+ *     tx: WebSQLTransaction,
+ *     success: KeySuccess,
+ *     error: FindError,
+ *     recordsToLoad?: Integer
+ *   ) => void,
+ *   __onsuccess: (success: SuccessArg) => SuccessCallback,
+ *   __decode: (
+ *     rowItem: RowItemNonNull,
+ *     callback: (
+ *       key: import('./Key.js').Key,
+ *       val: import('./Key.js').Value,
+ *       primaryKey: import('./Key.js').Key,
+ *       encKey?: string
+ *     ) => void
+ *   ) => void,
+ *   __sourceOrEffectiveObjStoreDeleted: () => void,
+ *   __continue: (key?: import('./Key.js').Key, advanceContinue?: boolean) => void,
+ *   __continueFinish: (
+ *     key: import('./Key.js').Key,
+ *     primaryKey: import('./Key.js').Key,
+ *     advanceState: boolean
+ *   ) => void
  * }} IDBCursorFull
  */
 
 /**
  * @typedef {IDBCursorFull & {
  *   __request: import('./IDBRequest.js').IDBRequestFull,
+ *   value: import('./Key.js').Value,
  * }} IDBCursorWithValueFull
  */
 
@@ -97,7 +140,7 @@ IDBCursor.__super = function IDBCursor (query, direction, store, source, keyColu
     }
     IDBTransaction.__assertActive(store.transaction);
     const range = convertValueToKeyRange(query);
-    if (direction !== undefined && !(['next', 'prev', 'nextunique', 'prevunique'].includes(direction))) {
+    if (direction !== undefined && !cursorDirections.includes(direction)) {
         throw new TypeError(direction + 'is not a valid cursor direction');
     }
 
@@ -175,14 +218,14 @@ IDBCursor.prototype.__find = function (...args /* key, tx, success, error, recor
  */
 
 /**
- * @typedef {(tx: SQLTransaction|Error|DOMException|SQLError, err?: SQLError) => void} FindError
+ * @typedef {(tx: WebSQLTransaction|Error|DOMException|(Error & {code?: number}), err?: (Error & {code?: number})) => void} FindError
  */
 
 /**
  *
  * @param {undefined|import('./Key.js').Key} key
  * @param {undefined|import('./Key.js').Key} primaryKey
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {KeySuccess} success
  * @param {FindError} error
  * @param {Integer|undefined} recordsToLoad
@@ -253,9 +296,9 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
             me.__prefetchedIndex = 0;
             me.__prefetchedData = data.rows;
             if (CFG.DEBUG) { console.log('Preloaded ' + me.__prefetchedData.length + ' records for cursor'); }
-            me.__decode(data.rows.item(0), success);
+            me.__decode(/** @type {RowItemNonNull} */ (data.rows.item(0)), success);
         } else if (data.rows.length === 1) {
-            me.__decode(data.rows.item(0), success);
+            me.__decode(/** @type {RowItemNonNull} */ (data.rows.item(0)), success);
         } else {
             if (CFG.DEBUG) { console.log('Reached end of cursors'); }
             success(undefined, undefined, undefined);
@@ -273,7 +316,7 @@ const leftBracketRegex = /\[/gu;
  *
  * @param {undefined|import('./Key.js').Key} key
  * @param {undefined|import('./Key.js').Key} primaryKey
- * @param {SQLTransaction} tx
+ * @param {WebSQLTransaction} tx
  * @param {KeySuccess} success
  * @param {FindError} error
  * @param {Integer} [recordsToLoad]
@@ -380,7 +423,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
             if (me.__count) { // Avoid caching and other processing below
                 let ct = 0;
                 for (let i = 0; i < data.rows.length; i++) {
-                    const rowItem = data.rows.item(i);
+                    const rowItem = /** @type {RowItemNonNull} */ (data.rows.item(i));
                     const rowKey = Key.decode(rowItem[me.__keyColumnName], true);
                     const matches = Key.findMultiEntryMatches(rowKey, me.__range);
                     ct += matches.length;
@@ -392,7 +435,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
             // Track how far we've physically scanned, regardless of whether
             // this batch produced any matches, so the next batch (if any)
             // resumes after this one instead of re-scanning or stopping early.
-            const lastRawRow = data.rows.item(data.rows.length - 1);
+            const lastRawRow = /** @type {RowItemNonNull} */ (data.rows.item(data.rows.length - 1));
             me.__continuationKey = Key.decode(lastRawRow[me.__keyColumnName], true);
             me.__continuationPrimaryKey = Key.decode(lastRawRow.key);
             if (data.rows.length < recordsToLoad) {
@@ -401,7 +444,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
 
             const rows = [];
             for (let i = 0; i < data.rows.length; i++) {
-                const rowItem = data.rows.item(i);
+                const rowItem = /** @type {RowItemNonNull} */ (data.rows.item(i));
                 const rowKey = Key.decode(rowItem[me.__keyColumnName], true);
                 const matches = Key.findMultiEntryMatches(rowKey, me.__range);
 
@@ -455,6 +498,7 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
                 length: rows.length,
                 /**
                  * @param {Integer} index
+                 * @this {{data: RowItemNonNull[]}}
                  * @returns {RowItemNonNull}
                  */
                 item (index) {
@@ -588,7 +632,7 @@ IDBCursor.prototype.__sourceOrEffectiveObjStoreDeleted = function () {
  * @returns {void}
  */
 IDBCursor.prototype.__invalidateCache = function () {
-    // @ts-expect-error Why is this not being found?
+    // @ts-ignore Why is this not being found?; needed under some TS versions
     this.__prefetchedData = null;
     this.__multiEntryExhausted = false;
 };
@@ -649,7 +693,29 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
                 if (me.__advanceCount && me.__advanceCount >= 2 && k !== undefined) {
                     me.__advanceCount--;
                     me.__key = k;
-                    me.__continue(undefined, true);
+                    me.__sourceOrEffectiveObjStoreDeleted();
+                    // This is an internal continuation step within a single
+                    //   `advance()` call, not a fresh user-facing dispatch --
+                    //   it's already part of an in-flight, already-validated
+                    //   operation, so briefly reopen the active-handler
+                    //   window `__pushToQueue` (via `__continueFinish`)
+                    //   checks, rather than routing back through the public
+                    //   `__continue()` (which would apply that check as if
+                    //   this were new activity from user code).
+                    const {transaction} = /** @type {{transaction: import('./IDBTransaction.js').IDBTransactionFull}} */ (
+                        me.__store
+                    );
+                    // `runQueuedRequest` (in `IDBTransaction.js`) resets both
+                    //   `__active` and `__handlerActive` to `false` right
+                    //   before invoking this op, so both -- not just
+                    //   `__handlerActive` -- need reopening here for
+                    //   `__pushToQueue`'s `__assertActive()` check below to
+                    //   pass.
+                    transaction.__active = true;
+                    transaction.__handlerActive = true;
+                    me.__continueFinish(undefined, undefined, true);
+                    transaction.__active = false;
+                    transaction.__handlerActive = false;
                     // We don't call success yet but do need to advance the transaction queue
                     util.runContinuationSafely(/** @type {() => void} */ (executeNextRequest));
                     return;
@@ -667,10 +733,25 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
                      * @returns {void}
                      */
                     function checkKey () {
-                        const cmpResult = Number(key === undefined) || cmp(k, key);
-                        if (cmpResult > 0 || (
-                            cmpResult === 0 && (
-                                me.__unique || primaryKey === undefined || cmp(primKey, primaryKey) >= 0
+                        if (key === undefined) {
+                            // No target key to compare against -- always accept the next
+                            //   prefetched record, regardless of direction.
+                            triggerSuccess(k, val, primKey);
+                            return;
+                        }
+                        // `cmp(k, key) > 0` ("has this record passed the target key?")
+                        //   only holds for an ascending (`next`) cursor; a descending
+                        //   (`prev`) one passes the target once `k` has dropped *below*
+                        //   it, i.e. `cmp(k, key) < 0` -- matching `continuePrimaryKey`'s
+                        //   own direction-aware comparisons above.
+                        const isPrev = me.direction.includes('prev');
+                        const keyCmp = cmp(k, key);
+                        const passedKey = isPrev ? keyCmp < 0 : keyCmp > 0;
+                        const atKey = keyCmp === 0;
+                        if (passedKey || (
+                            atKey && (
+                                me.__unique || primaryKey === undefined ||
+                                (isPrev ? cmp(primKey, primaryKey) <= 0 : cmp(primKey, primaryKey) >= 0)
                             )
                         )) {
                             triggerSuccess(k, val, primKey);
@@ -679,6 +760,16 @@ IDBCursor.prototype.__continueFinish = function (key, primaryKey, advanceState)
                         // @ts-expect-error Todo: Our bug to fix
                         util.runContinuationSafely(() => cursorContinue(tx, args, success, error));
                     }
+                    if (me.__multiEntryIndex && me.__unique && encKey === undefined) {
+                        // `__decode` found this row's matching key already seen
+                        //   (tracked via `__matchedKeys`) and signaled a skip by
+                        //   omitting `encKey`; move on to the next prefetched
+                        //   row instead of treating the missing key as the end
+                        //   of the cursor.
+                        // @ts-expect-error Todo: Our bug to fix
+                        util.runContinuationSafely(() => cursorContinue(tx, args, success, error));
+                        return;
+                    }
                     if (me.__unique && !me.__multiEntryIndex &&
                         encKey === Key.encode(me.key, me.__multiEntryIndex)) {
                         // @ts-expect-error Todo: Our bug to fix
@@ -822,6 +913,7 @@ IDBCursor.prototype.update = function (valueToUpdate) {
      */
     function addToQueue (clonedValue) {
         // We set the `invalidateCache` argument to `false` since the old value shouldn't be accessed
+        // @ts-ignore -- API (not erring in TS 6)
         IDBObjectStore.__storingRecordObjectStore(request, me.__store, false, clonedValue, false, key);
     }
     if (me.__store.keyPath !== null) {
@@ -832,7 +924,10 @@ IDBCursor.prototype.update = function (valueToUpdate) {
         // eslint-disable-next-line unicorn/prefer-hoisting-branch-code -- Different
         addToQueue(clonedValue);
     } else {
-        const clonedValue = Sca.clone(valueToUpdate);
+        const clonedValue = Sca.cloneWithInactiveTransaction(
+            /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (me.__store.transaction),
+            valueToUpdate
+        );
         addToQueue(clonedValue);
     }
     return request;
@@ -892,6 +987,7 @@ util.defineReadonlyOuterInterface(
     IDBCursor.prototype,
     ['source', 'direction', 'key', 'primaryKey', 'request']
 );
+util.setOperationNames(IDBCursor.prototype);
 Object.defineProperty(IDBCursor, 'prototype', {
     writable: false
 });
@@ -949,4 +1045,236 @@ Object.defineProperty(IDBCursorWithValue, 'prototype', {
 });
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
-export {IDBCursor, IDBCursorWithValue};
+/**
+ * Validates `direction` and fills in defaults for the `{query, count,
+ *   direction}` shape shared by `getAll`/`getAllKeys`/`getAllRecords`.
+ * @param {AnyValue} options
+ * @throws {TypeError}
+ * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ */
+function normalizeGetAllOptions (options) {
+    const {query, count, direction = 'next'} = /** @type {AnyValue} */ (options ?? {});
+    if (!cursorDirections.includes(direction)) {
+        throw new TypeError('`' + direction + '` is not a valid direction');
+    }
+    return {query, count, direction};
+}
+
+/**
+ * `getAll`/`getAllKeys` accept either the legacy `(query, count)` signature
+ *   or, per the IndexedDB 3 draft's `getAllRecords` options shape, a single
+ *   `{query, count, direction}` options object -- including an *empty*
+ *   `{}` (WPT's own tests call `getAll({})` expecting every record back,
+ *   the same as `getAll()`, not a `DataError` from treating `{}` as an
+ *   invalid key). A plain object is never a valid IndexedDB key (or key
+ *   range), so the two forms can be told apart unambiguously by the shape
+ *   of the first argument alone -- WPT's own `get_all_with_options_and_count_test`
+ *   deliberately calls `getAll(options, count)` (an extra, non-overload-matching
+ *   second argument, which JS simply ignores) to confirm the options-shaped
+ *   first argument wins regardless of how many arguments were actually passed.
+ * @param {IArguments} args
+ * @throws {TypeError}
+ * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ */
+function parseGetAllArgs (args) {
+    const arg0 = args[0];
+    if (util.isObj(arg0) && !Array.isArray(arg0) && !util.isDate(arg0) &&
+        !util.isBinary(arg0) &&
+        !('upper' in arg0 && 'lowerOpen' in arg0 && typeof arg0.lowerOpen === 'boolean') // IDBKeyRange-like
+    ) {
+        return normalizeGetAllOptions(arg0);
+    }
+    const [query, count] = args;
+    return normalizeGetAllOptions({query, count});
+}
+
+/**
+ * `getAllRecords` (IndexedDB 3.0) takes a single, optional `IDBGetAllOptions`
+ *   dictionary -- `{query, count, direction}` -- with no legacy positional
+ *   form to disambiguate against.
+ * @param {IArguments} args
+ * @throws {TypeError}
+ * @returns {{query: AnyValue, count: Integer|undefined, direction: string}}
+ */
+function parseGetAllRecordsArgs (args) {
+    return normalizeGetAllOptions(args[0]);
+}
+
+/**
+ * Shared implementation backing `getAll`/`getAllKeys`/`getAllRecords` on both
+ *   `IDBObjectStore` and `IDBIndex`. This walks a `find`/`decode` state
+ *   object using the exact same low-level primitives
+ *   (`__find`/`__findBasic`/`__findMultiEntry`/`__decode`) a real cursor's
+ *   `continue()` uses internally, so ordering and uniqueness semantics --
+ *   including `nextunique`/`prevunique` over `multiEntry` indexes -- always
+ *   match what iterating that same cursor manually would produce.
+ *
+ * Unlike a real cursor, none of the intermediate steps go through the
+ *   transaction's shared request queue (`__pushToQueue`): each step re-enters
+ *   the same queue slot's op function via a plain synchronous/callback chain
+ *   and only calls the queue's real `success` once, when every record has
+ *   been collected. This makes the whole operation occupy exactly one slot,
+ *   at its true issuance position, so its result event can't be reordered
+ *   relative to sibling requests queued around the same time -- which
+ *   driving this through the public, queue-based `openCursor()`/`continue()`
+ *   API (as this used to) cannot guarantee, since each subsequent `continue()`
+ *   step is appended to the end of the (by-then-longer) queue rather than
+ *   staying next to the steps before it.
+ * @param {import('./IDBObjectStore.js').IDBObjectStoreFull|
+ *   import('./IDBIndex.js').IDBIndexFull} source
+ * @param {import('./Key.js').Value} query
+ * @param {Integer|undefined} count
+ * @param {string} direction
+ * @param {"value"|"key"|"record"} mode
+ * @throws {TypeError}
+ * @returns {import('./IDBRequest.js').IDBRequestFull}
+ */
+function collectAll (source, query, count, direction, mode) {
+    const isIndexSource = util.instanceOf(source, IDBIndex);
+    if (!isIndexSource && !util.instanceOf(source, IDBObjectStore)) {
+        // Per Web IDL, an operation invoked on a `this` that isn't an
+        //   instance of the interface it's defined on must throw a
+        //   TypeError ("illegal invocation") -- checked here, rather than
+        //   left to fall through to `store.transaction`/`__assertActive`
+        //   below, since those instead throw `TransactionInactiveError`
+        //   for a `this` with no real `transaction` property.
+        throw new TypeError('Illegal invocation');
+    }
+    if (count !== undefined) {
+        count = util.enforceRange(count, 'unsigned long');
+    }
+    const indexSource = /** @type {import('./IDBIndex.js').IDBIndexFull} */ (source);
+    const store = /** @type {import('./IDBObjectStore.js').IDBObjectStoreFull} */ (
+        isIndexSource ? indexSource.objectStore : source
+    );
+    const tx = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (store.transaction);
+
+    IDBObjectStore.__invalidStateIfDeleted(store);
+    if (isIndexSource) {
+        IDBIndex.__invalidStateIfDeleted(indexSource);
+    }
+    IDBTransaction.__assertActive(tx);
+    const range = convertValueToKeyRange(query);
+    const multiEntryIndex = isIndexSource && Boolean(indexSource.multiEntry);
+    if (range !== undefined) {
+        // Encode the key range and cache the encoded values, matching what a
+        //   real cursor's constructor does, since `__findMultiEntry` reads
+        //   these cached values back off the range.
+        range.__lowerCached = range.lower !== undefined && Key.encode(range.lower, multiEntryIndex);
+        range.__upperCached = range.upper !== undefined && Key.encode(range.upper, multiEntryIndex);
+    }
+
+    // `getAllRecords` needs each record's value, so it (like `getAll`) must
+    //   decode the `value` column rather than the lighter-weight `key`-only
+    //   reads `getAllKeys` can get away with.
+    const needsValue = mode !== 'key';
+    const keyColumnName = isIndexSource ? util.escapeIndexNameForSQLKeyColumn(indexSource.name) : 'key';
+    const valueColumnName = needsValue ? 'value' : 'key';
+
+    // Inherits from `IDBCursor.prototype` (rather than being a plain object)
+    //   because `__find` dispatches to `this.__findBasic`/`this.__findMultiEntry`
+    //   as methods on `this`, not as functions looked up separately.
+    /** @type {IDBCursorFull} */
+    const state = /** @type {IDBCursorFull} */ (/** @type {unknown} */ (Object.assign(Object.create(IDBCursor.prototype), {
+        __store: store,
+        __indexSource: isIndexSource,
+        __range: range,
+        __keyColumnName: keyColumnName,
+        __valueColumnName: valueColumnName,
+        __valueDecoder: valueColumnName === 'key' ? Key : Sca,
+        __count: false,
+        __prefetchedIndex: -1,
+        __prefetchedData: null,
+        __continuationKey: undefined,
+        __continuationPrimaryKey: undefined,
+        __multiEntryExhausted: false,
+        __multiEntryIndex: multiEntryIndex,
+        __unique: direction.includes('unique'),
+        __sqlDirection: ['prev', 'prevunique'].includes(direction) ? 'DESC' : 'ASC',
+        __key: undefined
+    })));
+    // `direction` (unlike the `__`-prefixed internals above) is exposed as a
+    //   readonly getter on `IDBCursor.prototype` (via `defineReadonlyOuterInterface`)
+    //   that throws unless shadowed by an own property, exactly as a real
+    //   cursor's constructor shadows it -- a plain assignment would instead
+    //   hit that inherited accessor, which has no setter.
+    Object.defineProperty(state, 'direction', {writable: false, value: direction});
+
+    return tx.__addToTransactionQueue(function collectAllOp (sqlTx, args, success, error) {
+        /** @type {AnyValue[]} */
+        const results = [];
+        const recordsToLoad = count || CFG.cursorPreloadPackSize || 100;
+
+        /**
+         * @param {import('./Key.js').Key} k
+         * @param {import('./Key.js').Value} val
+         * @param {import('./Key.js').Key} primKey
+         * @returns {void}
+         */
+        function acceptOrFinish (k, val, primKey) {
+            if (k === undefined) {
+                success(results);
+                return;
+            }
+            state.__key = k;
+            switch (mode) {
+            case 'key':
+                results.push(primKey);
+                break;
+            case 'record':
+                results.push(IDBRecord.__createInstance(k, primKey, val));
+                break;
+            default:
+                results.push(val);
+            }
+            if (count && results.length >= count) {
+                success(results);
+                return;
+            }
+            util.runContinuationSafely(step);
+        }
+
+        /**
+         * @returns {void}
+         */
+        function step () {
+            if (state.__prefetchedData) {
+                state.__prefetchedIndex++;
+                if (state.__prefetchedIndex < state.__prefetchedData.length) {
+                    IDBCursor.prototype.__decode.call(
+                        state, state.__prefetchedData.item(state.__prefetchedIndex),
+                        /**
+                         * @param {import('./Key.js').Key} k
+                         * @param {import('./Key.js').Value} val
+                         * @param {import('./Key.js').Key} primKey
+                         * @param {string} [encKey]
+                         * @returns {void}
+                         */
+                        function (k, val, primKey, encKey) {
+                            if (state.__multiEntryIndex && state.__unique && encKey === undefined) {
+                                // `__decode` already saw this matching key (tracked
+                                //   via `__matchedKeys`) and signaled a skip.
+                                util.runContinuationSafely(step);
+                                return;
+                            }
+                            if (state.__unique && !state.__multiEntryIndex &&
+                                encKey === Key.encode(state.__key, state.__multiEntryIndex)) {
+                                util.runContinuationSafely(step);
+                                return;
+                            }
+                            acceptOrFinish(k, val, primKey);
+                        }
+                    );
+                    return;
+                }
+            }
+            IDBCursor.prototype.__find.call(
+                state, undefined, undefined, sqlTx, acceptOrFinish, error, recordsToLoad
+            );
+        }
+
+        step();
+    }, undefined, source);
+}
+
+export {IDBCursor, IDBCursorWithValue, parseGetAllArgs, parseGetAllRecordsArgs, collectAll};

package/src/IDBDatabase.js

@@ -25,11 +25,12 @@ const readonlyProperties = ['name', 'version', 'objectStoreNames'];
  * IDB Database Object.
  * @see https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface
  * @class
+ * @this {IDBDatabaseFull}
  * @throws {TypeError}
  */
 function IDBDatabase () {
     this.__versionTransaction = null;
-    this.__objectStores = null;
+    this.__objectStores = {};
     /** @type {import('./IDBTransaction.js').IDBTransactionFull[]} */
     this.__transactions = [];
     throw new TypeError('Illegal constructor');
@@ -51,27 +52,28 @@ const IDBDatabaseAlias = IDBDatabase;
  *   name: string,
  *   __forceClose: (msg: string) => void,
  *   __db: import('websql-configurable/lib/websql/WebSQLDatabase.js').default,
+ *   __closePending: boolean,
  *   __oldVersion: Integer,
  *   __version: Integer,
  *   __name: string,
  *   __upgradeTransaction: null|import('./IDBTransaction.js').IDBTransactionFull,
- *   __versionTransaction: import('./IDBTransaction.js').IDBTransactionFull,
+ *   __versionTransaction: null|import('./IDBTransaction.js').IDBTransactionFull,
  *   __transactions: import('./IDBTransaction.js').IDBTransactionFull[],
- *   __objectStores: {[key: string]: IDBObjectStore},
+ *   __objectStores: {[key: string]: import('./IDBObjectStore.js').IDBObjectStoreFull},
  *   __objectStoreNames: import('./DOMStringList.js').DOMStringListFull,
  *   __oldObjectStoreNames: import('./DOMStringList.js').DOMStringListFull,
  *   __unblocking: {
  *     check: () => void
- *   }
+ *   }[]
  * }} IDBDatabaseFull
  */
 
 /**
- * @param {import('websql-configurable').default} db
+ * @param {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} db
  * @param {string} name
  * @param {Integer} oldVersion
  * @param {Integer} version
- * @param {SQLResultSet} storeProperties
+ * @param {import('websql-configurable/lib/websql/WebSQLResultSet.js').default} storeProperties
  * @returns {IDBDatabaseFull}
  */
 IDBDatabase.__createInstance = function (db, name, oldVersion, version, storeProperties) {
@@ -85,6 +87,8 @@ IDBDatabase.__createInstance = function (db, name, oldVersion, version, storePro
         util.defineReadonlyProperties(this, readonlyProperties);
         this.__db = db;
         this.__closePending = false;
+        /** @type {{check: () => void}[]} */
+        this.__unblocking = [];
         this.__oldVersion = oldVersion;
         this.__version = version;
         this.__name = name;
@@ -102,12 +106,9 @@ IDBDatabase.__createInstance = function (db, name, oldVersion, version, storePro
         this.__objectStores = {};
         this.__objectStoreNames = DOMStringList.__createInstance();
 
-        /**
-         * @type {IDBObjectStoreProperties}
-         */
-        const itemCopy = {};
+        const itemCopy = /** @type {IDBObjectStoreProperties} */ ({});
         for (let i = 0; i < storeProperties.rows.length; i++) {
-            const item = storeProperties.rows.item(i);
+            const item = /** @type {{name: string, keyPath: string, autoInc: string, indexList: string}} */ (storeProperties.rows.item(i));
             // Safari implements `item` getter return object's properties
             //  as readonly, so we copy all its properties (except our
             //  custom `currNum` which we don't need) onto a new object
@@ -223,9 +224,14 @@ IDBDatabase.prototype.close = function () {
         throw new TypeError('Illegal invocation');
     }
     this.__closePending = true;
-    if (this.__unblocking) {
-        this.__unblocking.check();
-    }
+    // Multiple, separately-issued `open`/`deleteDatabase` requests can each
+    //   be waiting (concurrently) on this same connection to close -- e.g.
+    //   when an earlier one is still "blocked" but has already let the
+    //   connection queue move on to the next request -- so every registered
+    //   waiter must be notified, not just the most recently registered one.
+    this.__unblocking.forEach(function (/** @type {{check: () => void}} */ u) { u.check(); });
+    /** @type {{check: () => void}[]} */
+    this.__unblocking = [];
     this.__transactions = [];
 };
 
@@ -235,12 +241,14 @@ IDBDatabase.prototype.close = function () {
  * @this {IDBDatabaseFull}
  * @returns {import('./IDBTransaction.js').IDBTransactionFull}
  */
-IDBDatabase.prototype.transaction = function (storeNames /* , mode */) {
+IDBDatabase.prototype.transaction = function (storeNames /* , mode, options */) {
     if (arguments.length === 0) {
         throw new TypeError('You must supply a valid `storeNames` to `IDBDatabase.transaction`');
     }
     // eslint-disable-next-line prefer-rest-params -- API
     let mode = arguments[1];
+    // eslint-disable-next-line prefer-rest-params -- API
+    const options = arguments[2];
     storeNames = util.isIterable(storeNames)
         // Creating new array also ensures sequence is passed by value: https://heycam.github.io/webidl/#idl-sequence
         ? [...new Set( // to be unique
@@ -283,10 +291,18 @@ IDBDatabase.prototype.transaction = function (storeNames /* , mode */) {
         throw new TypeError('Invalid transaction mode: ' + mode);
     }
 
+    // Validated and reflected via `IDBTransaction.durability` for spec conformance only;
+    //   the SQLite/WebSQL backend has no equivalent flush/fsync knob to wire this to.
+    let durability = options && options.durability;
+    durability ||= 'default';
+    if (durability !== 'default' && durability !== 'strict' && durability !== 'relaxed') {
+        throw new TypeError('Invalid transaction durability: ' + durability);
+    }
+
     // Do not set transaction state to "inactive" yet (will be set after
     //   timeout on creating transaction instance):
     //   https://github.com/w3c/IndexedDB/issues/87
-    const trans = IDBTransaction.__createInstance(this, objectStoreNames, mode);
+    const trans = IDBTransaction.__createInstance(this, objectStoreNames, mode, durability);
     this.__transactions.push(trans);
     return trans;
 };
@@ -336,6 +352,7 @@ IDBDatabase.prototype.__forceClose = function (msg) {
 /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
 util.defineOuterInterface(IDBDatabase.prototype, listeners);
 util.defineReadonlyOuterInterface(IDBDatabase.prototype, readonlyProperties);
+util.setOperationNames(IDBDatabase.prototype);
 
 Object.defineProperty(IDBDatabase.prototype, 'constructor', {
     enumerable: false,