indexeddbshim 17.4.3 → 17.6.0

package/dist/nodeWebSQL.d.ts

@@ -15,5 +15,5 @@ export type SQLiteDatabaseInstance = {
  */
 export type SQLiteDatabaseConstructor = new (name: string, opts?: any) => SQLiteDatabaseInstance;
 declare const nodeWebSQL: (...args: unknown[]) => import("websql-configurable/lib/websql/WebSQLDatabase.js").default;
-import SQLiteDatabase from './nodeSQLiteDatabase.js';
+import SQLiteDatabase from 'websql-configurable/lib/sqlite/SQLiteDatabase.js';
 //# sourceMappingURL=nodeWebSQL.d.ts.map

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;AAgCrE,qHAAsK;2BAnD3I,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;AAgCrE,qHAAsK;2BAnD3I,kDAAkD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.4.3",
+  "version": "17.6.0",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -55,7 +55,6 @@
     "fix-permissions": "chmod +x node_modules/npm-run-all/bin/*/index.js",
     "lint": "eslint .",
     "eslint": "npm run lint --",
-    "sqlite-rebuild": "cd node_modules/sqlite3 && npm i",
     "w3c-build-only": "node test-support/node-buildjs",
     "w3c-build": "run-s clean-w3c clean-w3c-built w3c-build-only",
     "fake": "run-s clean-fake coverage:fake clean-fake",
@@ -168,13 +167,12 @@
   },
   "dependencies": {
     "@node-static/node-static": "^0.9.1",
-    "better-sqlite3": "^13.0.3",
     "canvas": "^3.2.3",
     "eventtargeter": "0.12.0",
     "sync-promise-expanded": "^2.0.0",
     "typeson": "10.2.0",
     "typeson-registry": "14.3.0",
-    "websql-configurable": "^3.1.0"
+    "websql-configurable": "^4.0.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
@@ -187,7 +185,6 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",
-    "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^26.4.0",
     "@types/websql": "^0.0.30",
     "@unicode/unicode-17.0.0": "^2.0.2",
@@ -202,7 +199,7 @@
     "coveradge": "^0.8.2",
     "delay-cli": "^3.0.0",
     "eslint": "^10.9.1",
-    "eslint-config-ash-nazg": "^42.6.0",
+    "eslint-config-ash-nazg": "^43.1.0",
     "globals": "^17.11.0",
     "is-date-object": "1.1.0",
     "isomorphic-fetch": "^3.0.0",
@@ -215,7 +212,7 @@
     "npm-run-all": "^4.1.5",
     "open-cli": "^9.0.0",
     "rimraf": "^6.1.3",
-    "rollup": "^4.63.0",
+    "rollup": "^4.63.1",
     "rollup-plugin-filesize": "^10.0.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "sinon": "^22.1.0",
@@ -227,7 +224,6 @@
   "allowScripts": {
     "es5-ext@0.10.64": true,
     "fsevents@2.3.3": true,
-    "sqlite3@5.1.7": true,
     "canvas@3.2.3": true,
     "unrs-resolver@1.12.2": true,
     "better-sqlite3@13.0.3": true,

package/src/IDBFactory.js

@@ -220,9 +220,7 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
 /**
  * @typedef {import('websql-configurable/lib/websql/WebSQLDatabase.js').default & {
  *   _db: {
- *     _db: {
- *       close: (errBack: (err: Error) => void) => void
- *     }
+ *     close: (errBack: (err: Error) => void) => void
  *   }
  * }} DatabaseFull
  */
@@ -304,7 +302,7 @@ function closeCachedWebSQLConnections (name, cb) {
         return;
     }
     dbs.forEach((db) => {
-        const sqliteDB = db._db && db._db._db;
+        const sqliteDB = db._db;
         if (!sqliteDB || !sqliteDB.close) {
             remaining--;
             if (remaining === 0) {
@@ -347,9 +345,9 @@ function cleanupDatabaseResources (__openDatabase, name, escapedDatabaseName, da
             databaseDeleted();
             return;
         }
-        const sqliteDB = latestSQLiteDBCached._db && latestSQLiteDBCached._db._db;
+        const sqliteDB = latestSQLiteDBCached._db;
         if (!sqliteDB || !sqliteDB.close) {
-            console.error('The `openDatabase` implementation does not have the expected `._db._db.close` method for closing the database');
+            console.error('The `openDatabase` implementation does not have the expected `._db.close` method for closing the database');
             return;
         }
         sqliteDB.close(
@@ -1229,7 +1227,7 @@ IDBFactory.prototype.databases = function () {
     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
+    //   deferred macrotask (see `websql-configurable`'s `SQLiteDatabase#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

package/src/IDBTransaction.js

@@ -56,7 +56,7 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'err
  *   __requestsFinished: boolean,
  *   __transFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
  *   __callTransFinishedCb: (err: boolean, cb: ((bool?: boolean) => void)) => void,
- *   __transactionEndCallback: () => void,
+ *   __transactionEndCallback: (() => void)|undefined,
  *   __transactionFinished: boolean,
  *   __completed: boolean,
  *   __transFinishedCbFired: boolean,
@@ -91,6 +91,19 @@ const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'err
  * }} IDBTransactionFull
  */
 
+/**
+ * @param {IDBTransactionFull} tx
+ * @returns {void}
+ */
+function releaseFinishedTransaction (tx) {
+    const pos = tx.db.__transactions.indexOf(tx);
+    if (pos !== -1) {
+        tx.db.__transactions.splice(pos, 1);
+    }
+    tx.__transactionEndCallback = undefined;
+    tx.__requests = [];
+}
+
 /**
  * The IndexedDB Transaction.
  * @see https://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#idl-def-IDBTransaction
@@ -645,6 +658,7 @@ IDBTransaction.prototype.__executeRequests = function () {
             } finally {
                 activeTransactions.delete(me);
                 me.__storeHandles = {};
+                releaseFinishedTransaction(me);
             }
         }
         if (me.mode === 'readwrite' || me.mode === 'readonly') {
@@ -928,6 +942,7 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                 me.dispatchEvent(evt);
                 me.__storeHandles = {};
                 me.dispatchEvent(createEvent('__abort'));
+                releaseFinishedTransaction(me);
             }, 0);
             return undefined;
         }).catch((err) => {

package/src/nodeWebSQL.js

@@ -1,5 +1,5 @@
 import customOpenDatabase from 'websql-configurable/custom/index.js';
-import SQLiteDatabase from './nodeSQLiteDatabase.js';
+import SQLiteDatabase from 'websql-configurable/lib/sqlite/SQLiteDatabase.js';
 import CFG from './CFG.js';
 
 /**
@@ -29,16 +29,16 @@ function wrappedSQLiteDatabase (name) {
     // @ts-ignore It's ok; needed under some TS versions
     const db = new SQLiteDatabase(name, {});
     if (CFG.sqlBusyTimeout) {
-        db._db.configure('busyTimeout', /** @type {number} */ (CFG.sqlBusyTimeout)); // Default is 1000
+        db.configure('busyTimeout', /** @type {number} */ (CFG.sqlBusyTimeout)); // Default is 1000
     }
     if (CFG.sqlTrace) {
-        db._db.configure('trace', CFG.sqlTrace);
+        db.configure('trace', CFG.sqlTrace);
     }
     if (CFG.sqlProfile) {
-        db._db.configure('profile', CFG.sqlProfile);
+        db.configure('profile', CFG.sqlProfile);
     }
     if (CFG.sqlMemoryQuota) {
-        db._db.configure('memoryQuota', /** @type {number} */ (CFG.sqlMemoryQuota));
+        db.configure('memoryQuota', /** @type {number} */ (CFG.sqlMemoryQuota));
     }
     return db;
 }

package/dist/nodeSQLiteDatabase.d.ts

@@ -1,64 +0,0 @@
-export default SQLiteDatabase;
-export type SQLProfileCallback = (sql: string, duration: number) => void;
-export type SQLTraceCallback = ((sql: string) => void) | undefined;
-/**
- * @class
- * @param {string} name
- * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
- * @this {{_db: any, _qFilePath: string}}
- * @returns {void}
- */
-declare function SQLiteDatabase(this: {
-    _db: any;
-    _qFilePath: string;
-}, name: string, opts?: {
-    busyTimeout?: number;
-    trace?: (sql: string) => void;
-    profile?: SQLProfileCallback;
-}): void;
-declare class SQLiteDatabase {
-    /**
-     * @class
-     * @param {string} name
-     * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
-     * @this {{_db: any, _qFilePath: string}}
-     * @returns {void}
-     */
-    constructor(this: {
-        _db: any;
-        _qFilePath: string;
-    }, name: string, opts?: {
-        busyTimeout?: number;
-        trace?: (sql: string) => void;
-        profile?: SQLProfileCallback;
-    });
-    _qFilePath: string;
-    _db: any;
-    /**
-     * @param {{sql: string, args: unknown[]}[]} queries
-     * @param {boolean} readOnly
-     * @param {(err: Error|null, results?: SQLiteResult[]) => void} callback
-     * @returns {void}
-     */
-    exec(queries: {
-        sql: string;
-        args: unknown[];
-    }[], readOnly: boolean, callback: (err: Error | null, results?: SQLiteResult[]) => void): void;
-}
-/**
- *
- */
-declare class SQLiteResult {
-    /**
-     * @param {Error|null|undefined} error
-     * @param {number|undefined} [insertId]
-     * @param {number} [rowsAffected]
-     * @param {object[]} [rows]
-     */
-    constructor(error: Error | null | undefined, insertId?: number | undefined, rowsAffected?: number, rows?: object[]);
-    error: Error | null | undefined;
-    insertId: number | undefined;
-    rowsAffected: number | undefined;
-    rows: object[] | undefined;
-}
-//# sourceMappingURL=nodeSQLiteDatabase.d.ts.map

package/dist/nodeSQLiteDatabase.d.ts.map

@@ -1 +0,0 @@
-{"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,CA4EhB;;IAjFD;;;;;;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,EA8E7F;IAzEG,mBAAsB;IAkBtB,SAsDE;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;;AArTD;;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/src/nodeSQLiteDatabase.js

@@ -1,314 +0,0 @@
-import Database from 'better-sqlite3';
-
-/**
- *
- */
-class SQLiteResult {
-    /**
-     * @param {Error|null|undefined} error
-     * @param {number|undefined} [insertId]
-     * @param {number} [rowsAffected]
-     * @param {object[]} [rows]
-     */
-    constructor (error, insertId, rowsAffected, rows) {
-        this.error = error;
-        this.insertId = insertId;
-        this.rowsAffected = rowsAffected;
-        this.rows = rows;
-    }
-}
-
-const READ_ONLY_ERROR = new Error(
-    'could not prepare statement (23 not authorized)'
-);
-
-/**
- * @typedef {(sql: string, duration: number) => void} SQLProfileCallback
- */
-
-/**
- * @typedef {((sql: string) => void)|undefined} SQLTraceCallback
- */
-
-// Two separate `better-sqlite3` connections (i.e., two separate
-//   `SQLiteDatabase` instances) can legitimately point at the same
-//   underlying file at once -- e.g. an old, about-to-close IndexedDB
-//   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 `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 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;
-
-/**
- * @class
- * @param {string} name
- * @param {{busyTimeout?: number, trace?: (sql: string) => void, profile?: SQLProfileCallback}} [opts]
- * @this {{_db: any, _qFilePath: string}}
- * @returns {void}
- */
-function SQLiteDatabase (name, opts = {}) {
-    this._qFilePath = name;
-    /** @type {import('better-sqlite3').Database} */
-    const db = new Database(name);
-
-    /** @type {SQLTraceCallback} */
-    // eslint-disable-next-line prefer-destructuring -- TS
-    let trace = opts.trace;
-    /** @type {SQLProfileCallback|undefined} */
-    // eslint-disable-next-line prefer-destructuring -- TS
-    let profile = opts.profile;
-
-    if (opts.busyTimeout) {
-        db.pragma('busy_timeout = ' + Number(opts.busyTimeout));
-    }
-
-    // Kept untyped (rather than the better-sqlite3 `Database` type) since that
-    //  type is internal to `@types/better-sqlite3` and can't be named in this
-    //  file's emitted declaration.
-    this._db = /** @type {any} */ ({
-        _db: db,
-        /**
-         * Compatibility with node-sqlite3's configure API.
-         * @param {'busyTimeout'|'trace'|'profile'|'memoryQuota'} option
-         * @param {number|((sql: string, duration?: number) => void)} value
-         * @returns {void}
-         */
-        configure (option, value) {
-            if (option === 'busyTimeout') {
-                db.pragma('busy_timeout = ' + Number(/** @type {number} */ (value)));
-                return;
-            }
-            if (option === 'trace') {
-                trace = /** @type {(sql: string) => void} */ (value);
-                return;
-            }
-            if (option === 'profile') {
-                profile = /** @type {SQLProfileCallback} */ (value);
-                return;
-            }
-            if (option === 'memoryQuota') {
-                const bytes = Number(value);
-                // `better-sqlite3` doesn't have a direct `sqlite3_quota_set` binding,
-                // but we can limit the max pages:
-                const pageSizeObj = db.pragma('page_size', {simple: true});
-                const pageSize = Number(pageSizeObj);
-                db.pragma('max_page_count = ' + Math.ceil(bytes / pageSize));
-            }
-        },
-        /**
-         * Compatibility with callback-oriented close semantics.
-         * @param {(err?: Error|null) => void} [cb]
-         * @returns {void}
-         */
-        close (cb) {
-            try {
-                db.close();
-                if (cb) {
-                    return cb(null);
-                }
-            } catch (err) {
-                if (cb) {
-                    return cb(/** @type {Error} */ (err));
-                }
-            }
-            return undefined;
-        },
-        getTrace () {
-            return trace;
-        },
-        getProfile () {
-            return profile;
-        }
-    });
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} sql
- * @param {unknown[]} args
- * @returns {object[]}
- */
-function runSelect (db, sql, args) {
-    const stmt = db.prepare(sql);
-    return stmt.reader ? /** @type {object[]} */ (stmt.all(...args)) : [];
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} sql
- * @param {unknown[]} args
- * @returns {import('better-sqlite3').RunResult}
- */
-function runNonSelect (db, sql, args) {
-    const stmt = db.prepare(sql);
-    return stmt.run(...args);
-}
-
-/**
- * @param {{sql: string, args: unknown[]}[]} queries
- * @param {boolean} readOnly
- * @param {(err: Error|null, results?: SQLiteResult[]) => void} callback
- * @returns {void}
- */
-SQLiteDatabase.prototype.exec = function exec (queries, readOnly, callback) {
-    // `:memory:` (SQLite/`better-sqlite3`'s own sentinel for an isolated,
-    //   non-shared in-memory database) can never actually collide with a
-    //   different connection -- each `new Database(':memory:')` call is
-    //   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 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;
-        }
-        if (readOnly) {
-            if (activeReaders) {
-                activeReaders.add(this);
-            } else {
-                fileReaders.set(filePath, new Set([this]));
-            }
-        } else {
-            fileWriter.set(filePath, this);
-        }
-    }
-
-    const db = this._db._db;
-    const len = queries.length;
-    const results = Array.from({length: len});
-
-    for (let i = 0; i < len; i++) {
-        const query = queries[i];
-        const {sql, args} = query;
-        const isSelect = (/^\s*SELECT\b/iu).test(sql);
-        if (readOnly && !isSelect) {
-            results[i] = new SQLiteResult(READ_ONLY_ERROR);
-            continue;
-        }
-        const trace = this._db.getTrace();
-        const profile = this._db.getProfile();
-        // eslint-disable-next-line unicorn/prefer-bigint-literals -- `0n` needs ES2020+ target for tsc
-        const start = profile ? process.hrtime.bigint() : BigInt(0);
-        try {
-            if (trace) {
-                trace(sql);
-            }
-            if (isSelect) {
-                const rows = runSelect(db, sql, args);
-                results[i] = new SQLiteResult(null, undefined, 0, rows);
-            } else {
-                const executionResult = runNonSelect(db, sql, args);
-                const insertId = Number(executionResult.lastInsertRowid);
-                results[i] = new SQLiteResult(null, insertId, executionResult.changes, []);
-            }
-        } catch (err) {
-            results[i] = new SQLiteResult(/** @type {Error} */ (err));
-        } finally {
-            if (profile) {
-                profile(sql, Number(process.hrtime.bigint() - start));
-            }
-        }
-    }
-    // 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. `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
-        //   waiter's own `exec` call can't run reentrantly inside this one.
-        // Checked across the whole batch, not just `queries[0]`: when a
-        //   transaction's `BEGIN` and its later `ROLLBACK`/`COMMIT` are both
-        //   queued synchronously before `websql-configurable`'s async flush
-        //   gets a turn to run (e.g. an immediate `transaction.abort()`
-        //   inside `onupgradeneeded`), they arrive coalesced into a single
-        //   batch/`exec()` call, with the terminal statement anywhere but
-        //   first -- so only checking `queries[0]` would acquire the lock
-        //   and never see the matching release, deadlocking every later
-        //   connection to the same file.
-        if (filePath && queries.some((q) => endRe.test(q.sql))) {
-            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);
-    });
-};
-
-export default SQLiteDatabase;