indexeddbshim 19.0.5 → 19.0.6

package/src/IDBFactory.js

@@ -148,6 +148,7 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
                 return undefined;
             }
             const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                 // @ts-ignore It's ok; needed under some TS versions
                 new IDBVersionChangeEvent('versionchange', {oldVersion, newVersion})
             );
@@ -193,6 +194,7 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
                 }
             };
             const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                 // @ts-ignore It's ok; needed under some TS versions
                 new IDBVersionChangeEvent('blocked', {oldVersion, newVersion})
             );
@@ -251,6 +253,13 @@ const pendingVersionChanges = new Map();
 
 /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
 let sysdb;
+// Tracks which `CFG.memoryDatabase` value `sysdb` was opened against, so a
+//   later change to that config (e.g. toggling in-memory mode on and back
+//   off) causes `sysdb` to be recreated for the new setting rather than
+//   staying pinned, forever, to whatever it was the first time any database
+//   was created in the process.
+/** @type {string|null|undefined} */
+let sysdbMemoryDatabaseSetting;
 let nameCounter = 0;
 
 /**
@@ -337,12 +346,20 @@ function closeCachedWebSQLConnections (name, cb) {
 function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError) {
     const useMemoryDatabase = typeof CFG.memoryDatabase === 'string';
     if (useMemoryDatabase) {
+        /* c8 ignore start -- Defensive: only reachable if `websqlDBCache[name]`
+           was initialized as an empty placeholder by `open()`'s connection-queue
+           setup (`addRequestToConnectionQueue`, above `openDB`) but never
+           populated with an actual instance -- e.g. `__openDatabase` throwing
+           after a `dbVersions` row already existed for `name` from an earlier,
+           successful `open()` -- or if `name` was never added to the cache at
+           all. Not reachable via normal, non-tampered API usage. */
         const latestSQLiteDBCached = Object.hasOwn(websqlDBCache, name) ? getLatestCachedWebSQLDB(name) : null;
         if (!latestSQLiteDBCached) {
             console.warn('Could not find a memory database instance to delete.');
             databaseDeleted();
             return;
         }
+        /* c8 ignore stop -- see comment above */
         const sqliteDB = latestSQLiteDBCached._db;
         if (!sqliteDB || !sqliteDB.close) {
             console.error('The `openDatabase` implementation does not have the expected `._db.close` method for closing the database');
@@ -404,15 +421,24 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
                     ), [], function () {
                         deleteTables(i + 1);
                     }, function () {
+                        /* c8 ignore start -- Defensive: continues deleting the rest
+                           even if this specific store's table is already gone (e.g.
+                           duplicate `__sys__` rows for the same escaped table name, or
+                           external tampering); not reachable via normal API usage. */
                         deleteTables(i + 1);
                         return false;
+                        /* c8 ignore stop -- see comment above */
                     });
                 }
             }(0));
         }, function () {
-            // __sys__ table does not exist, but that does not mean delete did not happen
+            /* c8 ignore start -- `__sys__` is always created by `openDB` before this
+               database's `dbVersions` row (a prerequisite for reaching this code at
+               all) is ever inserted; only reachable if the file was tampered with/
+               removed externally afterward. */
             databaseDeleted();
             return false;
+            /* c8 ignore stop -- see comment above */
         });
     });
 }
@@ -442,9 +468,11 @@ function createSysDB (__openDatabase, success, failure) {
         failure(er);
     }
 
-    if (sysdb) {
+    if (sysdb && sysdbMemoryDatabaseSetting === CFG.memoryDatabase) {
         success();
     } else {
+        // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Needed
+        sysdbMemoryDatabaseSetting = CFG.memoryDatabase;
         // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Necessary?
         sysdb = __openDatabase(
             typeof CFG.memoryDatabase === 'string'
@@ -643,6 +671,17 @@ IDBFactory.prototype.open = function (name /* , version */) {
                      * @returns {void}
                      */
                     let sysdbFinishedCb = function (systx, err, cb) {
+                        /* c8 ignore start -- This initial definition is always
+                           superseded before ever being invoked: the `sysdb.transaction(...)`
+                           call below always reaches its `nonstandardTransCb` (4th arg)
+                           after this same SQL batch finishes running (since `dbCreateError`
+                           always reports errors as "handled" and this call site is never
+                           a `readTransaction`), which unconditionally reassigns
+                           `sysdbFinishedCb` to a version using the library's own
+                           `rollback`/`commit` -- well before any real invocation from
+                           `on__beforecomplete`/`on__preabort`/`on__abort` below (those only
+                           fire once the upgrade transaction itself later completes/aborts).
+                           Kept as a defensive fallback in case that invariant ever changes. */
                         if (err) {
                             /**
                              * @param {unknown} [errorToShow]
@@ -709,6 +748,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                         }
                         // In browser, should auto-commit
                         cb(); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                        /* c8 ignore stop -- see comment above */
                     };
 
                     sysdb.transaction(function (systx) {
@@ -717,6 +757,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                          */
                         function versionSet () {
                             const e = /** @type {import('eventtargeter').EventWithProps & Event & IDBVersionChangeEvent} */ (
+                                // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                                 // @ts-ignore It's ok; needed under some TS versions
                                 new IDBVersionChangeEvent('upgradeneeded', {oldVersion, newVersion: version})
                             );
@@ -850,9 +891,16 @@ IDBFactory.prototype.open = function (name /* , version */) {
                             // eslint-disable-next-line camelcase -- Clear API
                             req.transaction.on__complete = function () {
                                 const pos = connection.__transactions.indexOf(req.transaction);
+                                // `req.transaction` (the versionchange transaction) is created
+                                //   directly via `IDBTransaction.__createInstance` above, never
+                                //   via `IDBDatabase.prototype.transaction()` (the only place
+                                //   that pushes onto `connection.__transactions`), so `pos` is
+                                //   always -1 here.
+                                /* c8 ignore start -- see comment above */
                                 if (pos !== -1) {
                                     connection.__transactions.splice(pos, 1);
                                 }
+                                /* c8 ignore stop -- see comment above */
 
                                 if (/** @type {import('./IDBDatabase.js').IDBDatabaseFull} */ (
                                     req.__result
@@ -890,9 +938,16 @@ IDBFactory.prototype.open = function (name /* , version */) {
                             systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [version, sqlSafeName], versionSet, dbCreateError);
                         }
                     }, dbCreateError, undefined, function (currentTask, err, done, rollback, commit) {
+                        // Defensive fallback, not reachable in practice: same reasoning
+                        //   as `deleteDatabase`'s own `nonstandardTransCb` below
+                        //   (`currentTask.readOnly` is always false here, and
+                        //   `dbCreateError` always returns `false`, so `err` is never
+                        //   truthy either).
+                        /* c8 ignore start -- see comment above */
                         if (currentTask.readOnly || err) {
                             return true;
                         }
+                        /* c8 ignore stop -- see comment above */
                         sysdbFinishedCb = function (systx, err, cb) {
                             if (err) {
                                 rollback(err,
@@ -915,7 +970,16 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                                     );
                                                 }
                                             },
+                                            // Deeply-nested defensive path: only reached if
+                                            //   the *revert* SQL (undoing the `dbVersions`
+                                            //   INSERT/UPDATE after the original version-
+                                            //   upgrade itself already failed) fails a
+                                            //   *second* time. Not feasibly triggerable
+                                            //   without fault-injecting the underlying SQL
+                                            //   driver on this specific, already-failing
+                                            //   revert statement.
                                             function (sqlErr) {
+                                                /* c8 ignore next 2 -- see comment above */
                                                 isRevertingSysdb = false;
                                                 cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                                             },
@@ -933,8 +997,20 @@ IDBFactory.prototype.open = function (name /* , version */) {
                     });
                     return undefined;
                 }).catch((err) => {
+                    /* c8 ignore start -- Purely defensive: nothing in
+                       `triggerAnyVersionChangeAndBlockedEvents`'s promise chain
+                       (or this `.then()` continuation above) ever rejects/throws
+                       under any reachable application-level condition -- all of
+                       its continuations resolve cleanly, and its `dispatchEvent`
+                       calls are deliberately fire-and-forget ("No need to catch
+                       errors"), running inside a `setTimeout` where a listener
+                       throwing becomes an uncaught exception in that macrotask
+                       rather than a promise rejection here. This exists solely
+                       to surface a truly-unexpected internal bug via the console
+                       before rethrowing, not to handle a real, testable error path. */
                     console.log('Error within `triggerAnyVersionChangeAndBlockedEvents`');
                     throw err;
+                    /* c8 ignore stop -- see comment above */
                 });
             } else {
                 finishRequest();
@@ -964,15 +1040,25 @@ IDBFactory.prototype.open = function (name /* , version */) {
             db = websqlDBCache[name][version];
         } else {
             db = /** @type {DatabaseFull} */ (me.__openDatabase(
-                useMemoryDatabase ? CFG.memoryDatabase : util.joinPath(CFG.databaseBasePath || '', escapedDatabaseName),
+                useMemoryDatabase
+                    ? /** @type {string} */ (CFG.memoryDatabase)
+                    : util.joinPath(CFG.databaseBasePath || '', escapedDatabaseName),
                 '1',
                 name,
                 CFG.DEFAULT_DB_SIZE
             ));
             if (useDatabaseCache) {
+                /* c8 ignore start -- Defensive: by the time `openDB` runs,
+                   `websqlDBCache[name]` has always already been created by
+                   `addRequestToConnectionQueue`'s own callback above (guarded
+                   by this same `useDatabaseCache` condition), which always
+                   runs first and unconditionally ensures the entry exists
+                   before ever calling `openDB`. Kept as a safety net in case
+                   that invariant ever changes. */
                 if (!(Object.hasOwn(websqlDBCache, name))) {
                     websqlDBCache[name] = {};
                 }
+                /* c8 ignore stop -- see comment above */
                 websqlDBCache[name][version] = db;
             }
         }
@@ -1128,6 +1214,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
                 req.__result = undefined;
                 req.__done = true;
                 const e = /** @type {Event & IDBVersionChangeEvent} */ (
+                    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                     // @ts-ignore It's ok; needed under some TS versions
                     new IDBVersionChangeEvent('success', {oldVersion: version, newVersion: null})
                 );
@@ -1169,9 +1256,23 @@ IDBFactory.prototype.deleteDatabase = function (name) {
                                 cleanupDatabaseResources(me.__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError);
                             }, dbError);
                         }, dbError, undefined, function (currentTask, err, done, rollback, commit) {
+                            /* c8 ignore start -- Defensive fallback, not reachable in
+                               practice: `currentTask.readOnly` is always `false` here
+                               (this callback is only ever attached to the writable
+                               `sysdb.transaction(...)` call above, never to a
+                               `sysdb.readTransaction(...)`), and `err` can only be
+                               truthy if the `DELETE FROM dbVersions` statement's own
+                               error callback (`dbError`) reports the failure back to
+                               `websql-configurable` as unhandled -- but `dbError`
+                               deliberately always `return`s `false`, which tells the
+                               library the error was already handled (and to keep
+                               `err` falsy here), precisely so this custom
+                               `sysdbFinishedCbDelete` rollback/commit path below is
+                               used instead of the library's own default rollback. */
                             if (currentTask.readOnly || err) {
                                 return true;
                             }
+                            /* c8 ignore stop -- see comment above */
                             sysdbFinishedCbDelete = function (err, cb) {
                                 if (err) {
                                     rollback(err, cb);
@@ -1289,10 +1390,9 @@ IDBFactory.prototype.databases = function () {
 };
 
 /**
- * @todo forceClose: Test
  * This is provided to facilitate unit-testing of the
  *  closing of a database connection with a forced flag:
- * <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>
+ * <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>.
  * @param {string} dbName
  * @param {Integer} connIdx
  * @param {string} msg

package/src/IDBIndex.js

@@ -66,7 +66,6 @@ const IDBIndexAlias = IDBIndex;
  *   __unique: boolean,
  *   __objectStore: import('./IDBObjectStore.js').IDBObjectStoreFull,
  *   __keyPath: import('./Key.js').KeyPath,
- *   __recreated?: boolean,
  *   __fetchIndexData: (
  *     range: Query,
  *     opType: "value"|"key"|"count",
@@ -173,6 +172,7 @@ IDBIndex.__createInstance = function (store, indexProperties) {
                         ['key', 'BLOB ' + (objectStore.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY')],
                         ['value', 'BLOB']
                     ].concat(
+                        // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                         // @ts-ignore Has numeric indexes instead of iterator; needed under some TS versions
                         [...objectStore.indexNames]
                             .filter((indexName) => indexName !== newName)
@@ -230,7 +230,7 @@ IDBIndex.__clone = function (index, store) {
     });
     /** @type {const} */ ([
         '__pendingCreate', '__pendingDelete', '__deleted',
-        '__originalName', '__recreated'
+        '__originalName'
     ]).forEach((p) => {
         // @ts-expect-error Why is this type "never"?
         idx[p] = index[p];
@@ -270,11 +270,12 @@ IDBIndex.__createIndex = function (store, index) {
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
         transaction
     ).__addNonRequestToTransactionQueue(function createIndex (tx, args, success, failure) {
-        const columnExists = idx && (idx.__deleted || idx.__recreated); // This check must occur here rather than earlier as properties may not have been set yet otherwise
+        const columnExists = idx && idx.__deleted; // This check must occur here rather than earlier as properties may not have been set yet otherwise
 
         /** @type {{[key: string]: boolean}} */
         let indexValues = {};
 
+        /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
         /**
          * @param {WebSQLTransaction} tx
          * @param {(Error & {code?: number})} err
@@ -283,6 +284,7 @@ IDBIndex.__createIndex = function (store, index) {
         function error (tx, err) {
             failure(createDOMException('UnknownError', 'Could not create index "' + indexName + '"' + err.code + '::' + err.message, err));
         }
+        /* c8 ignore stop -- see comment above */
 
         /**
          * @param {WebSQLTransaction} tx
@@ -343,12 +345,6 @@ IDBIndex.__createIndex = function (store, index) {
                         } else {
                             delete index.__pendingCreate;
                             delete indexHandle.__pendingCreate;
-                            if (index.__deleted) {
-                                delete index.__deleted;
-                                delete indexHandle.__deleted;
-                                index.__recreated = true;
-                                indexHandle.__recreated = true;
-                            }
                             indexValues = {};
                             success(store);
                         }
@@ -358,7 +354,7 @@ IDBIndex.__createIndex = function (store, index) {
         }
 
         const escapedStoreNameSQL = util.escapeStoreNameForSQL(storeName);
-        const escapedIndexNameSQL = util.escapeIndexNameForSQL(index.name);
+        const escapedIndexNameSQL = util.escapeIndexNameForSQL(indexName);
 
         /**
          * @param {WebSQLTransaction} tx
@@ -419,6 +415,7 @@ IDBIndex.__deleteIndex = function (store, index) {
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
         transaction
     ).__addNonRequestToTransactionQueue(function deleteIndex (tx, args, success, failure) {
+        /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
         /**
          * @param {WebSQLTransaction} tx
          * @param {(Error & {code?: number})} err
@@ -427,6 +424,7 @@ IDBIndex.__deleteIndex = function (store, index) {
         function error (tx, err) {
             failure(createDOMException('UnknownError', 'Could not delete index "' + index.name + '"', err));
         }
+        /* c8 ignore stop -- see comment above */
 
         /**
          * @returns {void}
@@ -435,7 +433,6 @@ IDBIndex.__deleteIndex = function (store, index) {
             // Update the object store's index list
             IDBIndex.__updateIndexList(store, tx, function (store) {
                 delete index.__pendingDelete;
-                delete index.__recreated;
                 index.__deleted = true;
                 if (indexHandle) {
                     indexHandle.__deleted = true;
@@ -505,21 +502,19 @@ IDBIndex.__updateIndexList = function (store, tx, success, failure) {
  * @param {Query} range
  * @param {"value"|"key"|"count"} opType
  * @param {boolean} nullDisallowed
- * @param {number} [count]
  * @this {IDBIndexFull}
  * @returns {import('./IDBRequest.js').IDBRequestFull}
  */
-IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed, count) {
+IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed) {
     const me = this;
-    if (count !== undefined) {
-        count = util.enforceRange(count, 'unsigned long');
-    }
 
     IDBIndex.__invalidStateIfDeleted(me);
     IDBObjectStore.__invalidStateIfDeleted(me.objectStore);
+    /* c8 ignore start -- Defensive: `IDBObjectStore.__invalidStateIfDeleted` just above already throws when `me.objectStore.__deleted` is true, so this identical check can never be reached. */
     if (me.objectStore.__deleted) {
         throw createDOMException('InvalidStateError', "This index's object store has been deleted");
     }
+    /* c8 ignore stop -- see comment above */
     IDBTransaction.__assertActive(me.objectStore.transaction);
 
     if (nullDisallowed && util.isNullish(range)) {
@@ -531,7 +526,6 @@ IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed, c
         me.objectStore.transaction
     ).__addToTransactionQueue(function (...args) {
         executeFetchIndexData(
-            count,
             ...fetchArgs,
             // @ts-expect-error It's ok
             ...args
@@ -666,7 +660,9 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
     const escapedTmpStoreNameSQL = util.sqlQuote('tmp_' + util.escapeStoreNameForSQL(storeName).slice(1, -1));
     const colNamesToPreserve = colInfoToPreserveArr.map((colInfo) => colInfo[0]);
     const colInfoToPreserve = colInfoToPreserveArr.map((colInfo) => colInfo.join(' '));
+    /* c8 ignore next -- Defensive: the sole caller always supplies a non-empty `colInfoToPreserveArr` (seeded with `key`/`value` column info), so the empty-array fallback is unreachable. */
     const listColInfoToPreserve = (colInfoToPreserve.length ? (colInfoToPreserve.join(', ') + ', ') : '');
+    /* c8 ignore next -- Defensive: see comment above. */
     const listColsToPreserve = (colNamesToPreserve.length ? (colNamesToPreserve.join(', ') + ', ') : '');
 
     // We could adapt the approach at https://stackoverflow.com/a/8430746/271577
@@ -674,6 +670,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */ (
         store.transaction
     ).__addNonRequestToTransactionQueue(function renameIndex (tx, args, success, error) {
+        /* c8 ignore start -- Defensive: only reached if one of the chained `CREATE TABLE`/`INSERT`/`DROP TABLE`/`ALTER TABLE` statements below fails, which is not reliably reproducible without mocking the SQL layer. */
         /**
          * @param {WebSQLTransaction} tx
          * @param {(Error & {code?: number})} err
@@ -682,6 +679,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
         function sqlError (tx, err) {
             error(err);
         }
+        /* c8 ignore stop -- see comment above */
         /**
          * @returns {void}
          */
@@ -690,8 +688,14 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                 cb(tx, success);
                 return;
             }
+            /* c8 ignore start -- Defensive: `__renameIndex`'s only caller (the `IDBIndex.prototype.name` setter) always supplies a `cb`, so this fallback is dead with the current call graph. */
             success();
         }
+        /* c8 ignore stop -- see comment above */
+        if (!CFG.useSQLiteIndexes) {
+            finish();
+            return;
+        }
         // See https://www.sqlite.org/lang_altertable.html#otheralter
         // We don't query for indexes as we already have the info
         // This approach has the advantage of auto-deleting indexes via the DROP TABLE
@@ -710,10 +714,6 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                     const sql = 'ALTER TABLE ' + escapedTmpStoreNameSQL + ' RENAME TO ' + escapedStoreNameSQL;
                     if (CFG.DEBUG) { console.log(sql); }
                     tx.executeSql(sql, [], function (tx) {
-                        if (!CFG.useSQLiteIndexes) {
-                            finish();
-                            return;
-                        }
                         const indexCreations = colNamesToPreserve
                             .slice(2) // Doing `key` separately and no need for index on `value`
                             .map((escapedIndexNameSQL) => new SyncPromise(function (resolve, reject) {
@@ -725,15 +725,18 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                                 // tx.executeSql(sql, [], function () {
                                 const sql = 'CREATE INDEX ' +
                                     escapedIndexToRecreate + ' ON ' + escapedStoreNameSQL + '(' + escapedIndexNameSQL + ')';
+                                /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
                                 if (CFG.DEBUG) { console.log(sql); }
                                 tx.executeSql(
                                     sql,
                                     [],
                                     resolve,
+                                    /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
                                     /** @type {SqlErrorCallback} */
                                     (function (tx, err) {
                                         reject(err);
                                     })
+                                    /* c8 ignore stop -- see comment above */
                                 );
                                 // }, function (tx, err) {
                                 //    reject(err);
@@ -752,16 +755,20 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                                         if (CFG.DEBUG) { console.log(sql); }
                                         tx.executeSql(
                                             sql, [], resolve,
+                                            /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
                                             /** @type {SqlErrorCallback} */
                                             (function (tx, err) {
                                                 reject(err);
                                             })
+                                            /* c8 ignore stop -- see comment above */
                                         );
                                     },
+                                    /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
                                     /** @type {SqlErrorCallback} */
                                     (function (tx, err) {
                                         reject(err);
                                     })
+                                    /* c8 ignore stop -- see comment above */
                                 );
                             })
                         );
@@ -769,8 +776,10 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                             /** @type {(reason: unknown) => PromiseLike<never>} */
                             (error)
                         ).catch((err) => {
+                            /* c8 ignore start -- Defensive: only reached if `finish` or the outer `error` callback itself throws; not reliably reproducible. */
                             console.log('Index rename error');
                             throw err;
+                            /* c8 ignore stop -- see comment above */
                         });
                     }, /** @type {SqlErrorCallback} */ (sqlError));
                 }, /** @type {SqlErrorCallback} */ (sqlError));
@@ -804,7 +813,6 @@ Object.defineProperty(IDBIndex, 'prototype', {
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
 /**
- * @param {number|null} count
  * @param {boolean} unboundedDisallowed
  * @param {IDBIndexFull} index
  * @param {boolean} hasKey
@@ -822,14 +830,11 @@ Object.defineProperty(IDBIndex, 'prototype', {
  * @returns {void}
  */
 function executeFetchIndexData (
-    count, unboundedDisallowed, index, hasKey, range, opType,
+    unboundedDisallowed, index, hasKey, range, opType,
     multiChecks, sql, sqlValues, tx, args, success, error
 ) {
     if (unboundedDisallowed) {
-        count = 1;
-    }
-    if (count) {
-        sql.push('LIMIT', String(count));
+        sql.push('LIMIT', '1');
     }
     const isCount = opType === 'count';
     if (CFG.DEBUG) { console.log('Trying to fetch data for Index', sql.join(' '), sqlValues); }
@@ -895,11 +900,15 @@ function executeFetchIndexData (
                         record = row;
                     }
                 }
-                if (record) {
-                    records.push(decode(record));
-                    if (unboundedDisallowed) {
-                        break;
-                    }
+                /* c8 ignore start -- Defensive: the SQL `LIKE` clause is a coarse pre-filter and this precise re-check in JS is meant to catch its false positives, but the encoding's per-character dash-prefix plus trailing-space delimiter (see `Key.js` string encoding) and fixed-length number encoding prevent one encoded value from ever being a spurious substring of another, so a `LIKE` hit always also passes this check in practice. */
+                if (!record) {
+                    continue;
+                }
+                /* c8 ignore stop -- see comment above */
+
+                records.push(decode(record));
+                if (unboundedDisallowed) {
+                    break;
                 }
             }
         } else {
@@ -914,8 +923,16 @@ function executeFetchIndexData (
         if (isCount) {
             success(recordCount);
         } else if (recordCount === 0) {
+            // `unboundedDisallowed` is always `true` here: this function is only reached (for
+            //   non-`count` `opType`s) via `get`/`getKey`, which always pass `nullDisallowed: true`
+            //   through as `unboundedDisallowed`. `getAll`/`getAllKeys`/`getAllRecords` use a
+            //   different (cursor-based) code path, so the `unboundedDisallowed`-`false` case
+            //   (returning `[]` here) is unreachable given current callers.
+            /* c8 ignore next -- see comment above */
             success(unboundedDisallowed ? undefined : []);
         } else {
+            // `unboundedDisallowed` is always `true` here; see comment above.
+            /* c8 ignore next -- see comment above */
             success(unboundedDisallowed ? records[0] : records);
         }
     }, /** @type {SqlErrorCallback} */ (error));

package/src/IDBKeyRange.js

@@ -223,10 +223,12 @@ function setSQLForKeyRange (
         sql.push(quotedKeyColumnName, (range.lowerOpen ? '>' : '>='), '?');
     }
     if (hasLower && hasUpper) { sql.push('AND'); }
-    if (hasUpper) {
-        sql.push(quotedKeyColumnName, (range.upperOpen ? '<' : '<='), '?');
-        sqlValues.push(util.escapeSQLiteStatement(/** @type {string} */ (encodedUpperKey)));
+    if (!hasUpper) {
+        return;
     }
+
+    sql.push(quotedKeyColumnName, (range.upperOpen ? '<' : '<='), '?');
+    sqlValues.push(util.escapeSQLiteStatement(/** @type {string} */ (encodedUpperKey)));
 }
 
 /**
@@ -239,10 +241,9 @@ function convertValueToKeyRange (value, nullDisallowed) {
     if (util.instanceOf(value, IDBKeyRange)) {
         // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)
         const range = /** @type {IDBKeyRangeFull} */ (value);
-        if (range.toString() !== '[object IDBKeyRange]') {
-            return IDBKeyRange.__createInstance(range.lower, range.upper, range.lowerOpen, range.upperOpen);
-        }
-        return range;
+        return range.toString() !== '[object IDBKeyRange]'
+            ? IDBKeyRange.__createInstance(range.lower, range.upper, range.lowerOpen, range.upperOpen)
+            : range;
     }
     if (util.isNullish(value)) {
         if (nullDisallowed) {