@earendil-works/pi-durable 0.99.2 → 1.0.0

package/dist/storage/sqlite/storage.js

@@ -6,8 +6,6 @@ const parseJson = (value) => JSON.parse(value);
 const encodeJson = (value) => JSON.stringify(value);
 // Some SQLite bindings replace lone UTF-16 surrogates. JSON encoding keeps indexed identities lossless.
 const encodeIndexedString = (value) => JSON.stringify(value);
-const getRow = (statement, ...params) => statement.get(...params);
-const allRows = (statement, ...params) => statement.all(...params);
 const cursorId = (cursor) => {
     const after = cursor?.after;
     if (after === undefined)
@@ -66,45 +64,23 @@ const writeId = (write) => {
             return undefined;
     }
 };
-class StatementCachingDatabase {
-    database;
-    statements = new Map();
-    constructor(database) {
-        this.database = database;
-    }
-    exec(sql) {
-        this.database.exec(sql);
-    }
-    prepare(sql) {
-        let statement = this.statements.get(sql);
-        if (statement === undefined) {
-            statement = this.database.prepare(sql);
-            this.statements.set(sql, statement);
-        }
-        return statement;
-    }
-    transaction(callback) {
-        return this.database.transaction(callback);
-    }
-    close() {
-        this.statements.clear();
-        return this.database.close();
-    }
-}
 /** Portable SQLite implementation of the Pico storage contract. */
 export class SqliteStorage {
     db;
     nextId;
     closed = false;
+    closing;
+    admittedReads = 0;
+    readsDrained;
     constructor(db, nextId) {
-        this.db = new StatementCachingDatabase(db);
+        this.db = db;
         this.nextId = nextId;
     }
     /** Initialize storage over an owned SQLite database facade. */
     static async open(db) {
         try {
             await applySqliteMigrations(db);
-            const metadata = getRow(db.prepare("SELECT next_id, next_seq FROM durable_metadata WHERE singleton = 1"));
+            const metadata = await db.get("SELECT next_id, next_seq FROM durable_metadata WHERE singleton = 1");
             if (metadata === undefined)
                 throw new Error("Durable SQLite metadata is missing");
             return new SqliteStorage(db, Number(metadata.next_id));
@@ -123,19 +99,17 @@ export class SqliteStorage {
         this.assertOpen();
         const documentActions = this.prepareDocumentActions(writes);
         const candidateNextId = this.candidateNextId(writes);
-        const seq = await this.db.transaction(() => {
-            const metadata = getRow(this.db.prepare("SELECT next_id, next_seq FROM durable_metadata WHERE singleton = 1"));
+        const seq = await this.db.transaction(async (transaction) => {
+            const metadata = await transaction.get("SELECT next_id, next_seq FROM durable_metadata WHERE singleton = 1");
             if (metadata === undefined)
                 throw new Error("Durable SQLite metadata is missing");
             const committedSeq = seqFromNumber(metadata.next_seq);
-            this.checkGlobalIds(writes);
-            this.checkDocumentActions(documentActions);
+            await this.checkGlobalIds(transaction, writes);
+            await this.checkDocumentActions(transaction, documentActions);
             for (const write of writes)
-                this.applyTableWrite(write, committedSeq);
-            this.applyDocumentActions(documentActions, committedSeq);
-            this.db
-                .prepare("UPDATE durable_metadata SET next_id = ?, next_seq = ? WHERE singleton = 1")
-                .run(String(Math.max(Number(metadata.next_id), candidateNextId)), committedSeq + 1);
+                await this.applyTableWrite(transaction, write, committedSeq);
+            await this.applyDocumentActions(transaction, documentActions, committedSeq);
+            await transaction.run("UPDATE durable_metadata SET next_id = ?, next_seq = ? WHERE singleton = 1", String(Math.max(Number(metadata.next_id), candidateNextId)), committedSeq + 1);
             return committedSeq;
         });
         this.nextId = Math.max(this.nextId, candidateNextId);
@@ -149,7 +123,7 @@ export class SqliteStorage {
     }
     async conversation(id, _context) {
         this.assertOpen();
-        const row = getRow(this.db.prepare("SELECT record FROM conversations WHERE id = ?"), id);
+        const row = await this.db.get("SELECT record FROM conversations WHERE id = ?", id);
         return row === undefined ? undefined : parseJson(row.record);
     }
     async scanConversations(query, limit, cursor, _context) {
@@ -165,11 +139,19 @@ export class SqliteStorage {
             params.push(query.ownerTaskId);
         }
         params.push(limit + 1);
-        const rows = allRows(this.db.prepare(`SELECT record FROM conversations WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`), ...params);
+        const rows = await this.db.all(`SELECT record FROM conversations WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`, ...params);
         return page(rows.map((row) => parseJson(row.record)), limit);
     }
-    async entry(idOrConversationId, idOrContext, context) {
-        this.assertOpen();
+    entry(idOrConversationId, idOrContext, context) {
+        return this.admitRead(() => this.readEntry(idOrConversationId, idOrContext, context));
+    }
+    findLatestHeadMarker(conversationId, atOrBeforeEntryId, _context) {
+        return this.admitRead(() => this.readLatestHeadMarker(conversationId, atOrBeforeEntryId));
+    }
+    scanEntries(query, limit, cursor, _context) {
+        return this.admitRead(() => this.readEntries(query, limit, cursor));
+    }
+    async readEntry(idOrConversationId, idOrContext, context) {
         const id = context === undefined
             ? idFromNumber(idOrConversationId)
             : typeof idOrContext === "number"
@@ -180,11 +162,11 @@ export class SqliteStorage {
         let conversation;
         if (context !== undefined) {
             const conversationId = idFromNumber(idOrConversationId);
-            conversation = this.readConversation(conversationId);
+            conversation = await this.readConversation(conversationId);
             if (conversation === undefined)
                 throw new Error(`Unknown conversation: ${conversationId}`);
         }
-        const row = getRow(this.db.prepare("SELECT record, commit_seq FROM entries WHERE id = ?"), id);
+        const row = await this.db.get("SELECT record, commit_seq FROM entries WHERE id = ?", id);
         if (row === undefined)
             return undefined;
         const entry = parseJson(row.record);
@@ -194,34 +176,32 @@ export class SqliteStorage {
                 if (conversation.parent === undefined)
                     return undefined;
                 upperEntryId = Math.min(upperEntryId, conversation.parent.at);
-                conversation = this.readConversation(conversation.parent.conversationId);
+                conversation = (await this.readConversation(conversation.parent.conversationId));
             }
             if (entry.id > upperEntryId)
                 return undefined;
         }
         return { entry, commitSeq: seqFromNumber(row.commit_seq) };
     }
-    async findLatestHeadMarker(conversationId, atOrBeforeEntryId, _context) {
-        this.assertOpen();
-        let conversation = this.readConversation(conversationId);
+    async readLatestHeadMarker(conversationId, atOrBeforeEntryId) {
+        let conversation = await this.readConversation(conversationId);
         if (conversation === undefined)
             throw new Error(`Unknown conversation: ${conversationId}`);
         let upper = atOrBeforeEntryId;
         while (true) {
             const row = upper === undefined
-                ? getRow(this.db.prepare("SELECT record FROM entries WHERE conversation_id = ? AND head IS NOT NULL ORDER BY id DESC LIMIT 1"), conversation.id)
-                : getRow(this.db.prepare("SELECT record FROM entries WHERE conversation_id = ? AND head IS NOT NULL AND id <= ? ORDER BY id DESC LIMIT 1"), conversation.id, upper);
+                ? await this.db.get("SELECT record FROM entries WHERE conversation_id = ? AND head IS NOT NULL ORDER BY id DESC LIMIT 1", conversation.id)
+                : await this.db.get("SELECT record FROM entries WHERE conversation_id = ? AND head IS NOT NULL AND id <= ? ORDER BY id DESC LIMIT 1", conversation.id, upper);
             if (row !== undefined)
                 return parseJson(row.record);
             if (conversation.parent === undefined)
                 return undefined;
             upper = upper === undefined ? conversation.parent.at : Math.min(upper, conversation.parent.at);
-            conversation = this.readConversation(conversation.parent.conversationId);
+            conversation = (await this.readConversation(conversation.parent.conversationId));
         }
     }
-    async scanEntries(query, limit, cursor, _context) {
-        this.assertOpen();
-        let conversation = this.readConversation(query.conversationId);
+    async readEntries(query, limit, cursor) {
+        let conversation = await this.readConversation(query.conversationId);
         if (conversation === undefined)
             throw new Error(`Unknown conversation: ${query.conversationId}`);
         const after = cursorId(cursor);
@@ -241,20 +221,20 @@ export class SqliteStorage {
                 params.push(upper);
             }
             params.push(limit + 1 - values.length);
-            const rows = allRows(this.db.prepare(`SELECT record FROM entries WHERE ${clauses.join(" AND ")} ORDER BY id DESC LIMIT ?`), ...params);
+            const rows = await this.db.all(`SELECT record FROM entries WHERE ${clauses.join(" AND ")} ORDER BY id DESC LIMIT ?`, ...params);
             values.push(...rows.map((row) => parseJson(row.record)));
             if (values.length > limit || conversation.parent === undefined)
                 break;
             upper = upper === undefined ? conversation.parent.at : Math.min(upper, conversation.parent.at);
             if (query.minEntryId !== undefined && upper < query.minEntryId)
                 break;
-            conversation = this.readConversation(conversation.parent.conversationId);
+            conversation = (await this.readConversation(conversation.parent.conversationId));
         }
         return page(values, limit);
     }
     async task(id, _context) {
         this.assertOpen();
-        const row = getRow(this.db.prepare("SELECT record FROM tasks WHERE id = ?"), id);
+        const row = await this.db.get("SELECT record FROM tasks WHERE id = ?", id);
         return row === undefined ? undefined : parseJson(row.record);
     }
     async scanTasks(query, limit, cursor, _context) {
@@ -282,12 +262,12 @@ export class SqliteStorage {
             params.push(query.background ? 1 : 0);
         }
         params.push(limit + 1);
-        const rows = allRows(this.db.prepare(`SELECT record FROM tasks WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`), ...params);
+        const rows = await this.db.all(`SELECT record FROM tasks WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`, ...params);
         return page(rows.map((row) => parseJson(row.record)), limit);
     }
     async submission(id, _context) {
         this.assertOpen();
-        const row = getRow(this.db.prepare("SELECT record FROM submissions WHERE id = ?"), id);
+        const row = await this.db.get("SELECT record FROM submissions WHERE id = ?", id);
         return row === undefined ? undefined : parseJson(row.record);
     }
     async scanSubmissions(query, limit, cursor, _context) {
@@ -303,34 +283,35 @@ export class SqliteStorage {
             params.push(query.status);
         }
         params.push(limit + 1);
-        const rows = allRows(this.db.prepare(`SELECT record FROM submissions WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`), ...params);
+        const rows = await this.db.all(`SELECT record FROM submissions WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`, ...params);
         return page(rows.map((row) => parseJson(row.record)), limit);
     }
     async submissionByRequest(conversationId, requestId, _context) {
         this.assertOpen();
-        const row = getRow(this.db.prepare("SELECT record FROM submissions WHERE conversation_id = ? AND request_id = ?"), conversationId, encodeIndexedString(requestId));
+        const row = await this.db.get("SELECT record FROM submissions WHERE conversation_id = ? AND request_id = ?", conversationId, encodeIndexedString(requestId));
         return row === undefined ? undefined : parseJson(row.record);
     }
     async findDocument(address, at, _context) {
         this.assertOpen();
         const parts = addressParts(address);
-        const statement = at === "current"
-            ? this.db.prepare(`SELECT record FROM documents
+        const sql = at === "current"
+            ? `SELECT record FROM documents
 					WHERE kind = ? AND scope_kind = ? AND owner_id = ? AND family = ? AND key_value = ?
-					AND retired_at IS NULL ORDER BY created_at DESC LIMIT 1`)
-            : this.db.prepare(`SELECT record FROM documents
+					AND retired_at IS NULL ORDER BY created_at DESC LIMIT 1`
+            : `SELECT record FROM documents
 					WHERE kind = ? AND scope_kind = ? AND owner_id = ? AND family = ? AND key_value = ?
 					AND created_at <= ? AND (retired_at IS NULL OR retired_at > ?)
-					ORDER BY created_at DESC LIMIT 1`);
+					ORDER BY created_at DESC LIMIT 1`;
         const params = [parts.kind, parts.scopeKind, parts.ownerId, parts.family, parts.keyValue];
         if (at !== "current")
             params.push(at, at);
-        const row = getRow(statement, ...params);
+        const row = await this.db.get(sql, ...params);
         return row === undefined ? undefined : parseJson(row.record);
     }
     async document(id, at, _context) {
         this.assertOpen();
-        return this.materializeDocument(id, at);
+        // The record and revision queries must observe one committed state; a commit between them can replace the base.
+        return this.db.transaction((transaction) => this.materializeDocument(transaction, id, at));
     }
     async scanDocuments(query, limit, cursor, _context) {
         this.assertOpen();
@@ -349,21 +330,45 @@ export class SqliteStorage {
             params.push(query.at, query.at);
         }
         params.push(limit + 1);
-        const rows = allRows(this.db.prepare(`SELECT record FROM documents WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`), ...params);
+        const rows = await this.db.all(`SELECT record FROM documents WHERE ${clauses.join(" AND ")} ORDER BY id LIMIT ?`, ...params);
         return page(rows.map((row) => parseJson(row.record)), limit);
     }
-    async close(_context) {
-        if (this.closed)
-            return;
-        this.closed = true;
+    close(_context) {
+        if (this.closing === undefined) {
+            this.closed = true;
+            this.closing = this.closeDatabase();
+        }
+        return this.closing;
+    }
+    async closeDatabase() {
+        if (this.admittedReads > 0) {
+            await new Promise((resolve) => {
+                this.readsDrained = resolve;
+            });
+        }
         await this.db.close();
     }
-    readConversation(id) {
-        const row = getRow(this.db.prepare("SELECT record FROM conversations WHERE id = ?"), id);
+    /**
+     * Run a read that issues several queries. Close waits for admitted reads, so their later queries never reach a
+     * closed database. Single-query reads and transactions are already ordered before close by the database.
+     */
+    async admitRead(read) {
+        this.assertOpen();
+        this.admittedReads++;
+        try {
+            return await read();
+        }
+        finally {
+            if (--this.admittedReads === 0)
+                this.readsDrained?.();
+        }
+    }
+    async readConversation(id) {
+        const row = await this.db.get("SELECT record FROM conversations WHERE id = ?", id);
         return row === undefined ? undefined : parseJson(row.record);
     }
-    materializeDocument(id, at) {
-        const row = getRow(this.db.prepare("SELECT record FROM documents WHERE id = ?"), id);
+    async materializeDocument(executor, id, at) {
+        const row = await executor.get("SELECT record FROM documents WHERE id = ?", id);
         if (row === undefined)
             return undefined;
         const record = parseJson(row.record);
@@ -373,13 +378,13 @@ export class SqliteStorage {
         if (!isAliveAt(record, at))
             return undefined;
         const upper = at === "current" ? Number.MAX_SAFE_INTEGER : at;
-        const base = getRow(this.db.prepare(`SELECT seq, kind, version, content FROM document_revisions
-				WHERE document_id = ? AND kind = 'base' AND seq <= ? ORDER BY seq DESC LIMIT 1`), id, upper);
+        const base = await executor.get(`SELECT seq, kind, version, content FROM document_revisions
+				WHERE document_id = ? AND kind = 'base' AND seq <= ? ORDER BY seq DESC LIMIT 1`, id, upper);
         if (base === undefined)
             throw new Error(`Document ${id} is missing a required base`);
         let value = parseJson(base.content);
-        const tail = allRows(this.db.prepare(`SELECT seq, kind, version, content FROM document_revisions
-				WHERE document_id = ? AND seq > ? AND seq <= ? ORDER BY seq`), id, base.seq, upper);
+        const tail = await executor.all(`SELECT seq, kind, version, content FROM document_revisions
+				WHERE document_id = ? AND seq > ? AND seq <= ? ORDER BY seq`, id, base.seq, upper);
         for (const revision of tail) {
             if (revision.kind !== "delta" || revision.version !== base.version) {
                 throw new Error(`Document ${id} crosses a stored version boundary without a base`);
@@ -397,16 +402,16 @@ export class SqliteStorage {
         }
         return nextId;
     }
-    checkGlobalIds(writes) {
+    async checkGlobalIds(executor, writes) {
         const claimed = new Map();
-        const lookup = this.db.prepare("SELECT record_type FROM record_ids WHERE id = ?");
         for (const write of writes) {
             if (write.type === "document.change" || write.type === "document.retire")
                 continue;
             const document = write.type === "document.create" || write.type === "document.copy";
             const table = document ? "document" : write.type;
             const id = document ? write.record.id : write.value.id;
-            const existing = getRow(lookup, id)?.record_type;
+            const existing = (await executor.get("SELECT record_type FROM record_ids WHERE id = ?", id))
+                ?.record_type;
             const earlier = claimed.get(id);
             if (table === "conversation" || table === "entry" || table === "document") {
                 if (existing !== undefined)
@@ -468,13 +473,13 @@ export class SqliteStorage {
         }
         return actions;
     }
-    checkDocumentActions(actions) {
+    async checkDocumentActions(executor, actions) {
         const liveCounts = new Map();
         for (const [id, action] of actions) {
             if (action.copy !== undefined && actions.has(action.copy.id)) {
                 throw new StorageRejected(`Document copy ${id} source is changed in the copy batch`);
             }
-            const row = getRow(this.db.prepare("SELECT record FROM documents WHERE id = ?"), id);
+            const row = await executor.get("SELECT record FROM documents WHERE id = ?", id);
             const existing = row === undefined ? undefined : parseJson(row.record);
             if (action.create === undefined && existing === undefined)
                 throw new Error(`Unknown document: ${id}`);
@@ -483,7 +488,7 @@ export class SqliteStorage {
             if (existing?.retiredAt !== undefined)
                 throw new Error(`Document ${id} is retired`);
             if (action.content?.kind === "delta") {
-                const previous = getRow(this.db.prepare("SELECT version FROM document_revisions WHERE document_id = ? ORDER BY seq DESC LIMIT 1"), id);
+                const previous = await executor.get("SELECT version FROM document_revisions WHERE document_id = ? ORDER BY seq DESC LIMIT 1", id);
                 if (previous === undefined)
                     throw new Error(`Document ${id} delta has no base`);
                 if (previous.version !== action.content.version) {
@@ -494,7 +499,7 @@ export class SqliteStorage {
             const key = addressKey(record);
             let live = liveCounts.get(key);
             if (live === undefined)
-                live = this.currentDocumentId(record) === undefined ? 0 : 1;
+                live = (await this.currentDocumentId(executor, record)) === undefined ? 0 : 1;
             if (action.retire && existing !== undefined)
                 live--;
             if (action.create !== undefined && !action.retire)
@@ -506,44 +511,36 @@ export class SqliteStorage {
                 throw new Error("Document address already has a current incarnation");
         }
     }
-    currentDocumentId(address) {
+    async currentDocumentId(executor, address) {
         const parts = addressParts(address);
-        const id = getRow(this.db.prepare(`SELECT id FROM documents
+        const id = (await executor.get(`SELECT id FROM documents
 				WHERE kind = ? AND scope_kind = ? AND owner_id = ? AND family = ? AND key_value = ? AND retired_at IS NULL
-				LIMIT 1`), parts.kind, parts.scopeKind, parts.ownerId, parts.family, parts.keyValue)?.id;
+				LIMIT 1`, parts.kind, parts.scopeKind, parts.ownerId, parts.family, parts.keyValue))?.id;
         return id === undefined ? undefined : idFromNumber(id);
     }
-    applyTableWrite(write, seq) {
+    async applyTableWrite(executor, write, seq) {
         switch (write.type) {
             case "conversation":
-                this.claimId(write.value.id, "conversation");
-                this.db
-                    .prepare("INSERT INTO conversations (id, owner_conversation_id, owner_task_id, record) VALUES (?, ?, ?, ?)")
-                    .run(write.value.id, write.value.owner?.conversationId ?? null, write.value.owner?.taskId ?? null, encodeJson(write.value));
+                await this.claimId(executor, write.value.id, "conversation");
+                await executor.run("INSERT INTO conversations (id, owner_conversation_id, owner_task_id, record) VALUES (?, ?, ?, ?)", write.value.id, write.value.owner?.conversationId ?? null, write.value.owner?.taskId ?? null, encodeJson(write.value));
                 break;
             case "entry":
-                this.claimId(write.value.id, "entry");
-                this.db
-                    .prepare("INSERT INTO entries (id, conversation_id, head, commit_seq, record) VALUES (?, ?, ?, ?, ?)")
-                    .run(write.value.id, write.value.conversationId, write.value.head ?? null, seq, encodeJson(write.value));
+                await this.claimId(executor, write.value.id, "entry");
+                await executor.run("INSERT INTO entries (id, conversation_id, head, commit_seq, record) VALUES (?, ?, ?, ?, ?)", write.value.id, write.value.conversationId, write.value.head ?? null, seq, encodeJson(write.value));
                 break;
             case "task":
-                this.claimId(write.value.id, "task");
-                this.db
-                    .prepare(`INSERT INTO tasks (id, conversation_id, kind, status, abort_requested, background, record)
+                await this.claimId(executor, write.value.id, "task");
+                await executor.run(`INSERT INTO tasks (id, conversation_id, kind, status, abort_requested, background, record)
 						VALUES (?, ?, ?, ?, ?, ?, ?)
 						ON CONFLICT(id) DO UPDATE SET conversation_id = excluded.conversation_id, kind = excluded.kind,
 						status = excluded.status, abort_requested = excluded.abort_requested,
-						background = excluded.background, record = excluded.record`)
-                    .run(write.value.id, write.value.conversationId, encodeIndexedString(write.value.kind), write.value.state.status, write.value.abortRequested ? 1 : 0, write.value.background ? 1 : 0, encodeJson(write.value));
+						background = excluded.background, record = excluded.record`, write.value.id, write.value.conversationId, encodeIndexedString(write.value.kind), write.value.state.status, write.value.abortRequested ? 1 : 0, write.value.background ? 1 : 0, encodeJson(write.value));
                 break;
             case "submission":
-                this.claimId(write.value.id, "submission");
-                this.db
-                    .prepare(`INSERT INTO submissions (id, conversation_id, request_id, status, record) VALUES (?, ?, ?, ?, ?)
+                await this.claimId(executor, write.value.id, "submission");
+                await executor.run(`INSERT INTO submissions (id, conversation_id, request_id, status, record) VALUES (?, ?, ?, ?, ?)
 						ON CONFLICT(id) DO UPDATE SET conversation_id = excluded.conversation_id,
-						request_id = excluded.request_id, status = excluded.status, record = excluded.record`)
-                    .run(write.value.id, write.value.conversationId, write.value.requestId === undefined ? null : encodeIndexedString(write.value.requestId), write.value.status, encodeJson(write.value));
+						request_id = excluded.request_id, status = excluded.status, record = excluded.record`, write.value.id, write.value.conversationId, write.value.requestId === undefined ? null : encodeIndexedString(write.value.requestId), write.value.status, encodeJson(write.value));
                 break;
             case "document.create":
             case "document.copy":
@@ -552,15 +549,15 @@ export class SqliteStorage {
                 break;
         }
     }
-    claimId(id, table) {
-        this.db.prepare("INSERT OR IGNORE INTO record_ids (id, record_type) VALUES (?, ?)").run(id, table);
+    async claimId(executor, id, table) {
+        await executor.run("INSERT OR IGNORE INTO record_ids (id, record_type) VALUES (?, ?)", id, table);
     }
-    applyDocumentActions(actions, seq) {
+    async applyDocumentActions(executor, actions, seq) {
         for (const [id, action] of actions) {
             let content = action.content;
             if (action.copy !== undefined) {
                 try {
-                    const stored = this.materializeDocument(action.copy.id, action.copy.at);
+                    const stored = await this.materializeDocument(executor, action.copy.id, action.copy.at);
                     if (stored === undefined)
                         throw new Error(`Fork source document ${action.copy.id} cannot be read`);
                     const create = action.create;
@@ -588,35 +585,30 @@ export class SqliteStorage {
                     ...(action.retire ? { retiredAt: seq } : {}),
                 };
                 const parts = addressParts(record);
-                this.claimId(id, "document");
-                this.db
-                    .prepare(`INSERT INTO documents
+                await this.claimId(executor, id, "document");
+                await executor.run(`INSERT INTO documents
 						(id, kind, family, key_value, scope_kind, owner_id, created_at, retired_at, record)
-						VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                    .run(id, parts.kind, parts.family, parts.keyValue, parts.scopeKind, parts.ownerId, seq, action.retire ? seq : null, encodeJson(record));
+						VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, parts.kind, parts.family, parts.keyValue, parts.scopeKind, parts.ownerId, seq, action.retire ? seq : null, encodeJson(record));
             }
             else {
-                const row = getRow(this.db.prepare("SELECT record FROM documents WHERE id = ?"), id);
+                const row = (await executor.get("SELECT record FROM documents WHERE id = ?", id));
                 record = parseJson(row.record);
             }
             if (content !== undefined) {
                 if (content.kind === "base" && isCurrentOnly(record)) {
-                    this.db.prepare("DELETE FROM document_revisions WHERE document_id = ?").run(id);
+                    await executor.run("DELETE FROM document_revisions WHERE document_id = ?", id);
                 }
                 const encodedContent = content.kind === "base" ? encodeJson(content.value) : encodeJson(content.ops);
-                this.db
-                    .prepare("INSERT INTO document_revisions (document_id, seq, kind, version, content) VALUES (?, ?, ?, ?, ?)")
-                    .run(id, seq, content.kind, content.version, encodedContent);
+                await executor.run("INSERT INTO document_revisions (document_id, seq, kind, version, content) VALUES (?, ?, ?, ?, ?)", id, seq, content.kind, content.version, encodedContent);
             }
             if (action.retire) {
                 if (action.create === undefined) {
                     record = { ...record, retiredAt: seq };
-                    this.db
-                        .prepare("UPDATE documents SET retired_at = ?, record = ? WHERE id = ?")
-                        .run(seq, encodeJson(record), id);
+                    await executor.run("UPDATE documents SET retired_at = ?, record = ? WHERE id = ?", seq, encodeJson(record), id);
+                }
+                if (isCurrentOnly(record)) {
+                    await executor.run("DELETE FROM document_revisions WHERE document_id = ?", id);
                 }
-                if (isCurrentOnly(record))
-                    this.db.prepare("DELETE FROM document_revisions WHERE document_id = ?").run(id);
             }
         }
     }