@procedures/sqlite 0.4.0 → 0.5.0

package/dist/storage.js

@@ -3,25 +3,28 @@
  *
  * `SqliteStorage` keeps the items of one collection in one table of a SQLite database: a file,
  * or `:memory:`. It implements `CollectionStorage` of `@procedures/client`, so a
- * `ProcedureServer`, an `ApiStorage` server and a `HybridStorage` can use it. The engine is
- * sql.js (SQLite in WebAssembly), through `@mark1russell7/docker-sqlite`: no native build.
+ * `ProcedureServer`, an `ApiStorage` server and a `HybridStorage` can use it.
  *
+ * - The storage has two engines (the option `engine`). The engine `node` is `node:sqlite` of
+ *   Node.js: it writes only the changed pages of the file. The engine `sqljs` is sql.js (SQLite in
+ *   WebAssembly) through `@mark1russell7/docker-sqlite`: it keeps the database in memory and
+ *   writes the whole file after a write. The default `auto` uses `node` when Node.js has it.
+ * - The two engines use the same file format: a file of one engine opens with the other.
  * - The table of a collection has the columns `id` (the key) and `value` (the JSON text of the
  *   item). A value goes through `JSON.stringify` and `JSON.parse`.
  * - A change log gives `getChangesSince()`. The table `_storage_log` has the last change of each
  *   id, and `_storage_versions` has the version of each collection: `<epoch>:<seq>`, as
  *   `InMemoryStorage` has. The epoch stays in the file, so a version stays valid after a restart.
  * - Each write runs in a transaction. A batch that fails changes nothing.
- * - The storage keeps the database in memory and writes the file after each write. A write ends
- *   after its file write. One file write can hold the changes of several writes.
- * - The storages of one file in one process share one database, so the storages of two tables in
- *   one file do not write over the changes of each other.
+ * - The storages of one file in one process share one database. Thus the storages of two tables
+ *   in one file keep the changes of each other.
+ * - A storage that only reads does not make the file.
  */
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { createConnection } from "@mark1russell7/docker-sqlite";
-/** The path of a database that is only in memory. */
-export const MEMORY_PATH = ":memory:";
+import { optionalMs } from "@procedures/client";
+import { MEMORY_PATH, checkEngine, openEngine, } from "./engines.js";
+export { MEMORY_PATH, isNodeSqliteAvailable } from "./engines.js";
 /** The pattern of a table name: a letter, then letters, digits and underscores. */
 const TABLE_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
 /**
@@ -34,33 +37,39 @@ export function checkTableName(name) {
     }
     return name;
 }
-/** The rows of a query, as objects. */
-function rows(db, sql, params = []) {
-    const statement = db.prepare(sql);
-    try {
-        statement.bind(params);
-        const out = [];
-        while (statement.step())
-            out.push(statement.getAsObject());
-        return out;
-    }
-    finally {
-        statement.free();
-    }
-}
-/** This function runs the work in a transaction. An error rolls back each change of the work. */
-function transaction(db, work) {
-    db.run("BEGIN");
+/**
+ * This function runs the work in a transaction. An error rolls back each change of the work.
+ * With `keep` false, the transaction always rolls back: the work only tests a change.
+ */
+function transaction(db, work, keep = true) {
+    // IMMEDIATE takes the write lock at the start, so the busy timeout applies to it. A deferred
+    // transaction of the engine node that reads and then writes can fail at once in WAL mode.
+    db.exec("BEGIN IMMEDIATE");
     try {
         const result = work();
-        db.run("COMMIT");
+        db.exec(keep ? "COMMIT" : "ROLLBACK");
         return result;
     }
     catch (error) {
-        db.run("ROLLBACK");
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // SQLite rolled back the transaction already
+        }
         throw error;
     }
 }
+/** This function runs several reads in one read transaction, so they see one state of the file. */
+function readTransaction(db, work) {
+    db.exec("BEGIN");
+    try {
+        return work();
+    }
+    finally {
+        db.exec("COMMIT");
+    }
+}
 /** The JSON text of a value. A value without JSON text is a `TypeError`. */
 function toJson(id, value) {
     let text;
@@ -81,32 +90,107 @@ function checkId(id) {
     return id;
 }
 // ---------------------------------------------------------------------------
+// The schema
+// ---------------------------------------------------------------------------
+const VERSIONS = "_storage_versions";
+const LOG = "_storage_log";
+const LOG_INDEX = `${LOG}_seq`;
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS ${VERSIONS} (
+    collection TEXT PRIMARY KEY,
+    epoch TEXT NOT NULL,
+    seq INTEGER NOT NULL,
+    floor INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS ${LOG} (
+    collection TEXT NOT NULL,
+    id TEXT NOT NULL,
+    seq INTEGER NOT NULL,
+    deleted INTEGER NOT NULL,
+    PRIMARY KEY (collection, id)
+  );
+  CREATE INDEX IF NOT EXISTS ${LOG_INDEX} ON ${LOG} (collection, seq);
+`;
+/** A new epoch: a version of another collection or of another file does not match it. */
+function newEpoch() {
+    return randomUUID().replaceAll("-", "").slice(0, 12);
+}
+/** This function throws when the table exists without the columns of a storage. */
+function checkColumns(db, table) {
+    const columns = new Set(db.all(`PRAGMA table_info("${table}")`).map((row) => row.name));
+    if (!columns.has("id") || !columns.has("value")) {
+        throw new Error(`The table ${table} exists, and it does not have the columns id and value of a SqliteStorage`);
+    }
+}
+/** True when the database has the tables of the change log, the table and its version. */
+function hasSchema(db, table) {
+    const names = db.all(`SELECT name FROM sqlite_master WHERE name IN (?, ?, ?, ?)`, [VERSIONS, LOG, LOG_INDEX, table]);
+    return names.length === 4 && db.all(`SELECT 1 FROM ${VERSIONS} WHERE collection = ?`, [table]).length > 0;
+}
+/**
+ * This function makes the tables of the change log and of a collection, and the version of the
+ * collection. A database that has them already does not change, so a storage that only reads
+ * does not write to an existing file.
+ */
+function prepareTable(db, table, epoch) {
+    if (hasSchema(db, table)) {
+        checkColumns(db, table);
+        return;
+    }
+    transaction(db, () => {
+        db.exec(SCHEMA);
+        db.exec(`CREATE TABLE IF NOT EXISTS "${table}" (id TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+        checkColumns(db, table);
+        db.run(`INSERT OR IGNORE INTO ${VERSIONS} (collection, epoch, seq, floor) VALUES (?, ?, 0, 0)`, [table, epoch]);
+    });
+}
+/**
+ * This function copies the schema of each collection, with its epoch, to the file that the node
+ * engine makes. A version that a storage gave before the file existed stays valid.
+ */
+const copySchema = (from, to) => {
+    for (const { collection, epoch } of from.all(`SELECT collection, epoch FROM ${VERSIONS}`)) {
+        prepareTable(to, checkTableName(collection), epoch);
+    }
+};
+// ---------------------------------------------------------------------------
 // The databases of the files, shared in the process
 // ---------------------------------------------------------------------------
 /** One open database and its file writes. */
 class SharedDatabase {
     path;
-    db;
-    saveFile;
+    open;
     /** The storages that use the database. */
     users = 0;
     closed = false;
     /**
-     * True when the database has a change that is not in the file. The tables that a storage makes
-     * when it opens are not a change: a storage that only reads does not make the file.
+     * The engine sqljs: true when the database has a change that is not in the file. The tables
+     * that a storage makes when it opens are not a change: a storage that only reads does not make
+     * the file.
      */
     dirty = false;
     /** The last file write. Its error is in the promise of the write that asked for it. */
     saving = Promise.resolve();
     /** A file write that waits for the running one. The writes that come before it starts share it. */
     next;
-    constructor(path, db, saveFile) {
+    constructor(path, open) {
         this.path = path;
-        this.db = db;
-        this.saveFile = saveFile;
+        this.open = open;
+    }
+    get engine() {
+        return this.open.engine;
     }
-    /** This method records a change, and gives the promise of the file write that holds it. */
+    /** True when the engine writes the whole file after a write: sql.js with a file. */
+    get savesFile() {
+        return this.open.engine === "sqljs" && this.path !== MEMORY_PATH;
+    }
+    /**
+     * This method records a change, and gives the promise of the file write that holds it. The
+     * engine node wrote the change at the commit of its transaction.
+     */
     changed() {
+        if (!this.savesFile)
+            return Promise.resolve();
         this.dirty = true;
         return this.save();
     }
@@ -115,7 +199,7 @@ class SharedDatabase {
      * starts after this call, so the file gets each change that came before the call.
      */
     save() {
-        if (this.path === MEMORY_PATH)
+        if (!this.savesFile)
             return Promise.resolve();
         if (this.next)
             return this.next;
@@ -126,7 +210,7 @@ class SharedDatabase {
                 return;
             this.dirty = false;
             try {
-                await this.saveFile();
+                await this.open.saveFile();
             }
             catch (error) {
                 this.dirty = true;
@@ -147,14 +231,13 @@ function fileKey(path) {
     const absolute = resolve(path);
     return process.platform === "win32" ? absolute.toLowerCase() : absolute;
 }
-async function openDatabase(path) {
-    const { db, save } = await createConnection({ dbPath: path });
-    return new SharedDatabase(path, db, save);
+async function openDatabase(path, engine, busyTimeoutMs) {
+    return new SharedDatabase(path, await openEngine(path, engine, busyTimeoutMs));
 }
 /** This function opens the database of a path, or gives the open database of the same file. */
-async function acquire(path) {
+async function acquire(path, engine, busyTimeoutMs) {
     if (path === MEMORY_PATH) {
-        const shared = await openDatabase(path);
+        const shared = await openDatabase(path, engine, busyTimeoutMs);
         shared.users++;
         return shared;
     }
@@ -162,19 +245,32 @@ async function acquire(path) {
     for (;;) {
         let entry = files.get(key);
         if (!entry) {
-            const opening = openDatabase(path);
-            entry = opening;
-            files.set(key, opening);
+            const opening = openDatabase(path, engine, busyTimeoutMs);
+            entry = { engine, database: opening };
+            files.set(key, entry);
+            const own = entry;
             opening.then((shared) => opened.set(key, shared), () => {
                 // A failed open does not stay: the next storage tries again
-                if (files.get(key) === opening)
+                if (files.get(key) === own)
                     files.delete(key);
             });
         }
-        const shared = await entry;
+        let shared;
+        try {
+            shared = await entry.database;
+        }
+        catch (error) {
+            // A storage with another engine choice failed to open the file: try with this choice
+            if (entry.engine !== engine)
+                continue;
+            throw error;
+        }
         // The last storage closed the database while this one waited: open the file again
         if (shared.closed)
             continue;
+        if (engine !== "auto" && shared.engine !== engine) {
+            throw new Error(`The file ${path} is open with the SQLite engine ${shared.engine} in this process: a storage with the engine ${engine} cannot share it. Give the engine auto or ${shared.engine}.`);
+        }
         shared.users++;
         return shared;
     }
@@ -205,31 +301,10 @@ async function release(shared) {
             files.delete(key);
         }
     }
-    shared.db.close();
+    shared.open.close();
     if (failure !== undefined)
         throw failure;
 }
-// ---------------------------------------------------------------------------
-// The storage
-// ---------------------------------------------------------------------------
-const VERSIONS = "_storage_versions";
-const LOG = "_storage_log";
-const SCHEMA = `
-  CREATE TABLE IF NOT EXISTS ${VERSIONS} (
-    collection TEXT PRIMARY KEY,
-    epoch TEXT NOT NULL,
-    seq INTEGER NOT NULL,
-    floor INTEGER NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS ${LOG} (
-    collection TEXT NOT NULL,
-    id TEXT NOT NULL,
-    seq INTEGER NOT NULL,
-    deleted INTEGER NOT NULL,
-    PRIMARY KEY (collection, id)
-  );
-  CREATE INDEX IF NOT EXISTS ${LOG}_seq ON ${LOG} (collection, seq);
-`;
 /**
  * A collection storage in a table of a SQLite database (roadmap R45).
  *
@@ -239,6 +314,7 @@ const SCHEMA = `
  * await users.set("123", { id: "123", name: "John" });
  * const user = await users.get("123"); // { id: "123", name: "John" }
  * const changes = await users.getChangesSince(); // { version, full: true, changed, deleted: [] }
+ * await users.getEngine(); // "node" on Node.js 22.13 or later, else "sqljs"
  * await users.close();
  * ```
  */
@@ -247,6 +323,8 @@ export class SqliteStorage {
     path;
     /** The table of the items. */
     table;
+    /** The engine choice of the options. `getEngine()` gives the engine that the storage uses. */
+    engine;
     maxTombstones;
     /** The quoted table name, for the SQL text. */
     quoted;
@@ -258,9 +336,11 @@ export class SqliteStorage {
         }
         this.path = options.path;
         this.table = checkTableName(options.table);
+        this.engine = checkEngine(options.engine ?? "auto");
+        const busyTimeoutMs = optionalMs(options.busyTimeout, "busyTimeout") ?? 5000;
         this.quoted = `"${this.table}"`;
         this.maxTombstones = Math.max(0, options.maxTombstones ?? 10_000);
-        this.opening = this.open();
+        this.opening = this.open(busyTimeoutMs);
         // An operation gives the error of the open. This handler only stops an unhandled rejection.
         this.opening.catch(() => undefined);
     }
@@ -269,47 +349,58 @@ export class SqliteStorage {
     //
     async get(id) {
         const db = await this.database();
-        const [row] = rows(db, `SELECT value FROM ${this.quoted} WHERE id = ?`, [checkId(id)]);
+        const [row] = db.all(`SELECT value FROM ${this.quoted} WHERE id = ?`, [checkId(id)]);
         return row === undefined ? undefined : JSON.parse(row.value);
     }
     async getAll() {
         const db = await this.database();
-        return rows(db, `SELECT value FROM ${this.quoted} ORDER BY rowid`).map((row) => JSON.parse(row.value));
+        return db.all(`SELECT value FROM ${this.quoted} ORDER BY rowid`).map((row) => JSON.parse(row.value));
     }
     /** Every item with its id, in the order of the first write of each id. */
     async getEntries() {
         return this.entries(await this.database());
     }
+    /** The ids of the items, in the order of the entries. The storage does not read the values. */
+    async getIds() {
+        const db = await this.database();
+        return db.all(`SELECT id FROM ${this.quoted} ORDER BY rowid`).map((row) => row.id);
+    }
     /**
      * The changes after a version (roadmap R28). A version of another storage, of another database
      * file, or older than the dropped deletes gives all items (`full: true`). A version stays valid
-     * after a restart, because the change log is in the file.
+     * after a restart, because the change log is in the file. The reads run in one read
+     * transaction, so a write of another process does not come between them.
      */
     async getChangesSince(since) {
         const db = await this.database();
-        const { epoch } = await this.opening;
-        const { seq, floor } = this.counter(db);
-        const version = `${epoch}:${seq}`;
-        const from = parseVersion(since, epoch, seq);
-        if (from === undefined || from < floor) {
-            return { version, full: true, changed: this.entries(db), deleted: [] };
-        }
-        const changed = rows(db, `SELECT l.id AS id, d.value AS value FROM ${LOG} l JOIN ${this.quoted} d ON d.id = l.id
-       WHERE l.collection = ? AND l.deleted = 0 AND l.seq > ? ORDER BY l.seq`, [this.table, from]).map((row) => [row.id, JSON.parse(row.value)]);
-        const deleted = rows(db, `SELECT id FROM ${LOG} WHERE collection = ? AND deleted = 1 AND seq > ? ORDER BY seq`, [this.table, from]).map((row) => row.id);
-        return { version, full: false, changed, deleted };
+        return readTransaction(db, () => {
+            const { epoch, seq, floor } = this.counter(db);
+            const version = `${epoch}:${seq}`;
+            const from = parseVersion(since, epoch, seq);
+            if (from === undefined || from < floor) {
+                return { version, full: true, changed: this.entries(db), deleted: [] };
+            }
+            const changed = db
+                .all(`SELECT l.id AS id, d.value AS value FROM ${LOG} l JOIN ${this.quoted} d ON d.id = l.id
+           WHERE l.collection = ? AND l.deleted = 0 AND l.seq > ? ORDER BY l.seq`, [this.table, from])
+                .map((row) => [row.id, JSON.parse(row.value)]);
+            const deleted = db
+                .all(`SELECT id FROM ${LOG} WHERE collection = ? AND deleted = 1 AND seq > ? ORDER BY seq`, [this.table, from])
+                .map((row) => row.id);
+            return { version, full: false, changed, deleted };
+        });
     }
     async find(predicate) {
         return (await this.getAll()).filter((item) => predicate(item));
     }
     async has(id) {
         const db = await this.database();
-        return rows(db, `SELECT 1 FROM ${this.quoted} WHERE id = ? LIMIT 1`, [checkId(id)]).length > 0;
+        return db.all(`SELECT 1 FROM ${this.quoted} WHERE id = ? LIMIT 1`, [checkId(id)]).length > 0;
     }
     async size() {
         const db = await this.database();
-        const [row] = rows(db, `SELECT COUNT(*) AS n FROM ${this.quoted}`);
-        return row?.n ?? 0;
+        const [row] = db.all(`SELECT COUNT(*) AS n FROM ${this.quoted}`);
+        return Number(row?.n ?? 0);
     }
     //
     // ═══ Write Operations ═══
@@ -324,7 +415,7 @@ export class SqliteStorage {
     }
     async clear() {
         await this.write((db, next) => {
-            for (const { id } of rows(db, `SELECT id FROM ${this.quoted} ORDER BY rowid`))
+            for (const { id } of db.all(`SELECT id FROM ${this.quoted} ORDER BY rowid`))
                 this.logChange(db, id, next(), true);
             db.run(`DELETE FROM ${this.quoted}`);
         });
@@ -334,6 +425,8 @@ export class SqliteStorage {
     //
     /** This method sets several items in one transaction. When one value is not JSON, nothing changes. */
     async setBatch(items) {
+        // After close(), an empty batch rejects too
+        this.checkOpen();
         const texts = items.map(([id, value]) => [checkId(id), toJson(id, value)]);
         if (texts.length === 0)
             return;
@@ -344,6 +437,7 @@ export class SqliteStorage {
     }
     /** This method deletes several items in one transaction. */
     async deleteBatch(ids) {
+        this.checkOpen();
         for (const id of ids)
             checkId(id);
         if (ids.length === 0)
@@ -358,38 +452,39 @@ export class SqliteStorage {
     }
     async getBatch(ids) {
         const db = await this.database();
+        const rows = db.firstOfEach(`SELECT value FROM ${this.quoted} WHERE id = ?`, ids.map((id) => [checkId(id)]));
         const result = new Map();
-        const statement = db.prepare(`SELECT value FROM ${this.quoted} WHERE id = ?`);
-        try {
-            for (const id of ids) {
-                statement.bind([checkId(id)]);
-                if (statement.step())
-                    result.set(id, JSON.parse(statement.getAsObject()["value"]));
-                statement.reset();
-            }
-        }
-        finally {
-            statement.free();
-        }
+        rows.forEach((row, index) => {
+            if (row !== undefined)
+                result.set(ids[index], JSON.parse(row.value));
+        });
         return result;
     }
     //
     // ═══ Lifecycle & Metadata ═══
     //
+    /** The engine that the storage uses: `node` or `sqljs`. With the option `auto`, the open decides it. */
+    async getEngine() {
+        this.checkOpen();
+        const shared = await this.opening;
+        this.checkOpen();
+        return shared.engine;
+    }
     /**
      * This method writes the database file. Each write ends after its file write already, so a
-     * caller needs it only after a failed file write.
+     * caller needs it only after a failed file write of the engine `sqljs`. The engine `node`
+     * writes each change at its commit.
      */
     async flush() {
-        const { shared } = await this.opening;
-        if (this.closed)
-            return;
+        this.checkOpen();
+        const shared = await this.opening;
+        this.checkOpen();
         await shared.save();
     }
     /**
      * This method writes the file and releases the database. The items stay in the file. A new
      * storage of the same file and table reads them, and the versions of this storage stay valid.
-     * After `close()`, each operation throws.
+     * After `close()`, each operation rejects, and a second `close()` does nothing.
      */
     async close() {
         if (this.closed)
@@ -397,7 +492,7 @@ export class SqliteStorage {
         this.closed = true;
         let shared;
         try {
-            ({ shared } = await this.opening);
+            shared = await this.opening;
         }
         catch {
             // The open failed: there is nothing to release
@@ -406,81 +501,93 @@ export class SqliteStorage {
         await release(shared);
     }
     async getMetadata() {
+        const size = await this.size();
+        const engine = await this.getEngine();
         return {
             type: "custom",
-            size: await this.size(),
-            stats: { backend: "sqlite", table: this.table, memory: this.path === MEMORY_PATH },
+            size,
+            stats: { backend: "sqlite", engine, table: this.table, memory: this.path === MEMORY_PATH },
         };
     }
     //
     // ═══ Internal Helpers ═══
     //
     /** This method opens the database, and makes the tables of the collection and of the change log. */
-    async open() {
-        const shared = await acquire(this.path);
+    async open(busyTimeoutMs) {
+        const shared = await acquire(this.path, this.engine, busyTimeoutMs);
         try {
-            const db = shared.db;
-            db.exec(SCHEMA);
-            db.exec(`CREATE TABLE IF NOT EXISTS ${this.quoted} (id TEXT PRIMARY KEY, value TEXT NOT NULL)`);
-            const columns = new Set(rows(db, `PRAGMA table_info(${this.quoted})`).map((row) => row.name));
-            if (!columns.has("id") || !columns.has("value")) {
-                throw new Error(`The table ${this.table} exists, and it does not have the columns id and value of a SqliteStorage`);
-            }
-            db.run(`INSERT OR IGNORE INTO ${VERSIONS} (collection, epoch, seq, floor) VALUES (?, ?, 0, 0)`, [
-                this.table,
-                randomUUID().replaceAll("-", "").slice(0, 12),
-            ]);
-            const [row] = rows(db, `SELECT epoch FROM ${VERSIONS} WHERE collection = ?`, [this.table]);
-            return { shared, epoch: row.epoch };
+            prepareTable(shared.open.db, this.table, newEpoch());
+            return shared;
         }
         catch (error) {
             await release(shared).catch(() => undefined);
             throw error;
         }
     }
-    /** The open database. It throws after `close()`. */
+    /** The open database. It throws after `close()`, so the promise of the operation rejects. */
     async database() {
+        const shared = await this.sharedDatabase();
+        // The engine node: another process made the file after the open
+        shared.open.refresh(copySchema);
+        return shared.open.db;
+    }
+    async sharedDatabase() {
         this.checkOpen();
-        const { shared } = await this.opening;
+        const shared = await this.opening;
         this.checkOpen();
-        return shared.db;
+        return shared;
     }
     checkOpen() {
         if (this.closed)
             throw new Error(`The SQLite storage of the table ${this.table} is closed`);
     }
     entries(db) {
-        return rows(db, `SELECT id, value FROM ${this.quoted} ORDER BY rowid`).map((row) => [row.id, JSON.parse(row.value)]);
+        return db.all(`SELECT id, value FROM ${this.quoted} ORDER BY rowid`).map((row) => [row.id, JSON.parse(row.value)]);
     }
     counter(db) {
-        const [row] = rows(db, `SELECT seq, floor FROM ${VERSIONS} WHERE collection = ?`, [this.table]);
-        return { seq: row?.seq ?? 0, floor: row?.floor ?? 0 };
+        const [row] = db.all(`SELECT epoch, seq, floor FROM ${VERSIONS} WHERE collection = ?`, [this.table]);
+        return { epoch: row?.epoch ?? "", seq: Number(row?.seq ?? 0), floor: Number(row?.floor ?? 0) };
     }
     /**
-     * One write: the change in a transaction with the change log, then the file write. `next` gives
-     * the next number of the change log. A write that changes nothing writes no file.
+     * One write: the change in a transaction with the change log, then the file write of the engine
+     * `sqljs`. `next` gives the next number of the change log. A write that changes nothing writes
+     * no file.
+     *
+     * Before the first write, the engine `node` keeps the database of a missing file in memory, with
+     * no item. A write first tests its change there. When it changes an item, the storage makes the
+     * file and runs the write in it.
      */
     async write(change) {
-        const db = await this.database();
+        const shared = await this.sharedDatabase();
+        const { open } = shared;
+        open.refresh(copySchema);
+        if (open.waiting) {
+            const test = this.runWrite(open.db, change, false);
+            if (!test.changed)
+                return test.value;
+            open.makeFile(copySchema);
+        }
+        const { value, changed } = this.runWrite(open.db, change, true);
+        if (changed)
+            await shared.changed();
+        return value;
+    }
+    runWrite(db, change, keep) {
         let changed = false;
-        const result = transaction(db, () => {
+        const value = transaction(db, () => {
             const counter = this.counter(db);
             const next = () => {
                 changed = true;
                 return ++counter.seq;
             };
-            const value = change(db, next);
+            const result = change(db, next);
             if (changed) {
                 this.trimTombstones(db, counter);
                 db.run(`UPDATE ${VERSIONS} SET seq = ?, floor = ? WHERE collection = ?`, [counter.seq, counter.floor, this.table]);
             }
-            return value;
-        });
-        if (changed) {
-            const { shared } = await this.opening;
-            await shared.changed();
-        }
-        return result;
+            return result;
+        }, keep);
+        return { value, changed };
     }
     /** This method writes an item. An existing id keeps its place in the order. */
     put(db, id, text, next) {
@@ -489,8 +596,7 @@ export class SqliteStorage {
     }
     /** This method deletes an item. True when it existed. */
     remove(db, id, next) {
-        db.run(`DELETE FROM ${this.quoted} WHERE id = ?`, [id]);
-        if (db.getRowsModified() === 0)
+        if (db.run(`DELETE FROM ${this.quoted} WHERE id = ?`, [id]) === 0)
             return false;
         this.logChange(db, id, next(), true);
         return true;
@@ -501,15 +607,16 @@ export class SqliteStorage {
     }
     /** This method drops the oldest deletes above the limit, and moves the floor of the change log. */
     trimTombstones(db, counter) {
-        const [row] = rows(db, `SELECT COUNT(*) AS n FROM ${LOG} WHERE collection = ? AND deleted = 1`, [this.table]);
-        const excess = (row?.n ?? 0) - this.maxTombstones;
+        const [row] = db.all(`SELECT COUNT(*) AS n FROM ${LOG} WHERE collection = ? AND deleted = 1`, [this.table]);
+        const excess = Number(row?.n ?? 0) - this.maxTombstones;
         if (excess <= 0)
             return;
-        const [cut] = rows(db, `SELECT seq FROM ${LOG} WHERE collection = ? AND deleted = 1 ORDER BY seq LIMIT 1 OFFSET ?`, [this.table, excess - 1]);
+        const params = [this.table, excess - 1];
+        const [cut] = db.all(`SELECT seq FROM ${LOG} WHERE collection = ? AND deleted = 1 ORDER BY seq LIMIT 1 OFFSET ?`, params);
         if (cut === undefined)
             return;
         db.run(`DELETE FROM ${LOG} WHERE collection = ? AND deleted = 1 AND seq <= ?`, [this.table, cut.seq]);
-        counter.floor = Math.max(counter.floor, cut.seq);
+        counter.floor = Math.max(counter.floor, Number(cut.seq));
     }
 }
 /** The number of a version of this collection, or undefined for another or an unknown version. */