sliftutils 1.4.81 → 1.4.83

package/storage/proxydatabase/transactionSet.ts

@@ -4,8 +4,12 @@ import { Database } from "./Database";
 // structuredClone keeps typed arrays / Maps / undefined intact through the round-trip.
 const transactionCbor = new cborx.Encoder({ structuredClone: true });
 
-// On the store: files keyed by a monotonic number, each a CBOR array of transactions; a transaction sets one key (value undefined = delete) and carries a global sequence number. Replaying every transaction in sequence order (last write wins) gives the current map. Mutations append a file, then fold the whole set into one once enough accumulate.
-export type TransactionSetStore = { [fileNumber: string]: Uint8Array };
+// On the store: files keyed by a monotonic number, each a CBOR array of transactions; a transaction sets one key (value undefined = delete) and carries a global sequence number. Replaying every transaction in sequence order (last write wins) gives the current map. Mutations append a file, then fold the whole set into one once enough accumulate. Value is phantom — it only records what the encoded values deserialize to.
+declare const valueTag: unique symbol;
+export type TransactionSetStore<Value> = {
+    [fileNumber: string]: Uint8Array;
+    [valueTag]?: Value;
+};
 
 type Transaction = { sequence: number; key: string; value: unknown };
 
@@ -32,13 +36,15 @@ function decodeBuffers(buffers: Uint8Array[]): Transaction[] {
     return transactions;
 }
 
-function readTransactionFiles(
-    database: Database<TransactionSetStore>,
+function readTransactionFiles<Value>(
+    database: Database<TransactionSetStore<Value>>,
 ): { fileKeys: string[]; transactions: Transaction[] } | undefined {
-    const snapshot = database.readData(store => ({
-        fileKeys: Object.keys(store),
-        buffers: Object.values(store),
-    }));
+    const snapshot = database.readData(store => {
+        // A never-written / deleted set reads as empty (vs the whole readData being undefined = not synced).
+        const present = store as TransactionSetStore<Value> | undefined;
+        if (!present) return { fileKeys: [] as string[], buffers: [] as Uint8Array[] };
+        return { fileKeys: Object.keys(present), buffers: Object.values(present) };
+    });
     if (!snapshot) return undefined;
     return { fileKeys: snapshot.fileKeys, transactions: decodeBuffers(snapshot.buffers) };
 }
@@ -58,14 +64,17 @@ function replay(transactions: Transaction[]): Map<string, unknown> {
 }
 
 // Deletes old files by their ORIGINAL string key, so a stray non-numeric key still gets removed.
-function compactTransactions(
-    database: Database<TransactionSetStore>,
+function compactTransactions<Value>(
+    database: Database<TransactionSetStore<Value>>,
     allTransactions: Transaction[],
     oldFileKeys: string[],
     newFileNumber: number,
 ): void {
     const finalState = replay(allTransactions);
-    const merged: Transaction[] = [...finalState].map(([key, value], index) => ({ sequence: index, key, value }));
+    const merged: Transaction[] = [];
+    for (const key of finalState.keys()) {
+        merged.push({ sequence: merged.length, key, value: finalState.get(key) });
+    }
     const encoded = transactionCbor.encode(merged) as Uint8Array;
     database.writeData(store => store[String(newFileNumber)], encoded);
     for (const fileKey of oldFileKeys) {
@@ -74,28 +83,29 @@ function compactTransactions(
 }
 
 export function transactionRead<Value>(
-    database: Database<TransactionSetStore>,
+    database: Database<TransactionSetStore<Value>>,
 ): Map<string, Value> | undefined {
     const files = readTransactionFiles(database);
     if (!files) return undefined;
     return replay(files.transactions) as Map<string, Value>;
 }
 
-// Replay an already-read store object (no read of its own), so a caller can fetch many sets in one batched read and then materialize each.
-export function replayTransactionStore<Value>(store: TransactionSetStore | undefined): Map<string, Value> {
+// Replay an already-read store (no read of its own), so a caller can fetch many sets in one batched read and materialize each.
+export function replayTransactionStore<Value>(store: TransactionSetStore<Value> | undefined): Map<string, Value> {
     if (!store) return new Map();
     return replay(decodeBuffers(Object.values(store))) as Map<string, Value>;
 }
 
+// Fire-and-forget: no caller should care whether this "succeeded". If the set isn't synced for reading
+// yet it simply does nothing this pass and the caller's retry wrapper re-runs the whole operation later.
 export function transactionMutate<Value>(
-    database: Database<TransactionSetStore>,
+    database: Database<TransactionSetStore<Value>>,
     transactions: { key: string; value: Value | undefined }[],
     compactAfterFiles: number = DEFAULT_COMPACT_AFTER_FILES,
-): true | undefined {
+): void {
+    if (!transactions.length) return;
     const files = readTransactionFiles(database);
-    if (!files) return undefined;
-    if (!transactions.length) return true;
-
+    if (!files) return;
     const baseSequence = maxNumber(files.transactions.map(transaction => transaction.sequence), -1) + 1;
     const incoming: Transaction[] = transactions.map((transaction, index) => ({
         sequence: baseSequence + index,
@@ -103,12 +113,23 @@ export function transactionMutate<Value>(
         value: transaction.value,
     }));
     const nextFileNumber = maxNumber(files.fileKeys.map(fileKey => Number(fileKey)), -1) + 1;
-
     if (files.fileKeys.length + 1 >= compactAfterFiles) {
-        compactTransactions(database, [...files.transactions, ...incoming], files.fileKeys, nextFileNumber);
+        compactTransactions(database, files.transactions.concat(incoming), files.fileKeys, nextFileNumber);
     } else {
         const encoded = transactionCbor.encode(incoming) as Uint8Array;
         database.writeData(store => store[String(nextFileNumber)], encoded);
     }
-    return true;
+}
+
+// Fire-and-forget like transactionMutate: clears the whole set by deleting every file. deleteData only removes
+// a primitive leaf (not a store object), so we delete each file key individually. No-ops (the retry re-runs)
+// if the store isn't synced yet.
+export function transactionDelete<Value>(
+    database: Database<TransactionSetStore<Value>>,
+): void {
+    const files = readTransactionFiles(database);
+    if (!files) return;
+    for (const fileKey of files.fileKeys) {
+        database.deleteData(store => store[fileKey]);
+    }
 }