@rotorsoft/act-sqlite 1.22.4 → 1.22.6

package/dist/index.js

@@ -1,5 +1,7 @@
 // src/sqlite-store.ts
-import { createClient } from "@libsql/client";
+import {
+  createClient
+} from "@libsql/client";
 import {
   ConcurrencyError,
   is_literal_source,
@@ -117,8 +119,8 @@ var SqliteStore = class {
     return parsed;
   }
   async seed() {
-    await this.client.execute("PRAGMA journal_mode=WAL");
-    await this.client.execute(`
+    await this._exec("PRAGMA journal_mode=WAL");
+    await this._exec(`
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         stream TEXT NOT NULL,
@@ -132,22 +134,22 @@ var SqliteStore = class {
       )
     `);
     try {
-      await this.client.execute("ALTER TABLE events ADD COLUMN pii TEXT");
+      await this._exec("ALTER TABLE events ADD COLUMN pii TEXT");
     } catch {
     }
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_events_stream ON events(stream)"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_events_name ON events(name)"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_events_snapshot ON events(stream, id) WHERE name = '__snapshot__'"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_events_stream_id ON events(stream, id) WHERE name <> '__snapshot__'"
     );
-    await this.client.execute(`
+    await this._exec(`
       CREATE TABLE IF NOT EXISTS streams (
         stream TEXT PRIMARY KEY,
         source TEXT,
@@ -164,40 +166,36 @@ var SqliteStore = class {
       )
     `);
     try {
-      await this.client.execute(
+      await this._exec(
         "ALTER TABLE streams ADD COLUMN priority INTEGER NOT NULL DEFAULT 0"
       );
     } catch {
     }
     try {
-      await this.client.execute(
-        "ALTER TABLE streams ADD COLUMN deferred_at TEXT"
-      );
+      await this._exec("ALTER TABLE streams ADD COLUMN deferred_at TEXT");
     } catch {
     }
     try {
-      await this.client.execute(
+      await this._exec(
         "ALTER TABLE streams ADD COLUMN lane TEXT NOT NULL DEFAULT 'default'"
       );
     } catch {
     }
     try {
-      await this.client.execute(
-        "ALTER TABLE streams ADD COLUMN correlated_at INTEGER"
-      );
+      await this._exec("ALTER TABLE streams ADD COLUMN correlated_at INTEGER");
     } catch {
     }
-    await this.client.execute(
+    await this._exec(
       `UPDATE streams
        SET correlated_at = (SELECT COALESCE(MAX(id), -1) FROM events)
        WHERE correlated_at IS NULL`
     );
-    const correlated_columns = await this.client.execute(
+    const correlated_columns = await this._exec(
       "PRAGMA table_info(correlated)"
     );
     const legacy = correlated_columns.rows.some((r) => r.name === "id");
     if (legacy) {
-      await this.client.execute(`
+      await this._exec(`
         CREATE TABLE IF NOT EXISTS correlated_keyed (
           key TEXT PRIMARY KEY,
           at INTEGER NOT NULL DEFAULT -1,
@@ -205,15 +203,13 @@ var SqliteStore = class {
           leased_until INTEGER
         )
       `);
-      await this.client.execute(
+      await this._exec(
         "INSERT OR IGNORE INTO correlated_keyed (key, at) SELECT '', at FROM correlated WHERE id = 0"
       );
-      await this.client.execute("DROP TABLE correlated");
-      await this.client.execute(
-        "ALTER TABLE correlated_keyed RENAME TO correlated"
-      );
+      await this._exec("DROP TABLE correlated");
+      await this._exec("ALTER TABLE correlated_keyed RENAME TO correlated");
     } else {
-      await this.client.execute(`
+      await this._exec(`
         CREATE TABLE IF NOT EXISTS correlated (
           key TEXT PRIMARY KEY,
           at INTEGER NOT NULL DEFAULT -1,
@@ -222,104 +218,127 @@ var SqliteStore = class {
         )
       `);
     }
-    await this.client.execute(
-      "INSERT OR IGNORE INTO correlated (key) VALUES ('')"
-    );
-    await this.client.execute(
+    await this._exec("INSERT OR IGNORE INTO correlated (key) VALUES ('')");
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_streams_claim ON streams(blocked, priority DESC, at)"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_streams_correlated_at ON streams(lane, priority DESC, at) WHERE blocked = 0 AND at < correlated_at"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_streams_correlated_at_any_lane ON streams(priority DESC, at) WHERE blocked = 0 AND at < correlated_at"
     );
-    await this.client.execute(
+    await this._exec(
       "CREATE INDEX IF NOT EXISTS idx_streams_lane ON streams(lane)"
     );
   }
   async drop() {
-    await this.client.execute("DROP TABLE IF EXISTS events");
-    await this.client.execute("DROP TABLE IF EXISTS streams");
-    await this.client.execute("DROP TABLE IF EXISTS correlated");
+    await this._exec("DROP TABLE IF EXISTS events");
+    await this._exec("DROP TABLE IF EXISTS streams");
+    await this._exec("DROP TABLE IF EXISTS correlated");
   }
-  // One write transaction: any failure rolls back and throws a {@link StoreError} naming the operation.
-  async _tx(operation, work) {
-    const tx = await this.client.transaction("write");
-    try {
-      const result = await work(tx);
-      await tx.commit();
-      return result;
-    } catch (e) {
-      await tx.rollback();
+  // One connection serves the whole store, and it can't run a statement
+  // while a write transaction is open on it: a second one fails at once
+  // (`TRANSACTION_ACTIVE` in memory, `SQLITE_BUSY` on a file) instead of
+  // waiting. So every statement and every transaction takes its turn here.
+  // A turn covers only the database work, never a caller's callback, so a
+  // callback that writes to the store can't wait on itself.
+  _turn = Promise.resolve();
+  _serial(work) {
+    const run = this._turn.then(work);
+    this._turn = run.catch(() => void 0);
+    return run;
+  }
+  // One statement, in its turn.
+  _exec(stmt) {
+    return this._serial(() => this.client.execute(stmt));
+  }
+  // Opens a write transaction: a BEGIN that fails is a {@link StoreError} too.
+  _begin(operation) {
+    return this.client.transaction("write").catch((e) => {
       throw new StoreError(operation, { cause: e });
-    }
+    });
+  }
+  // One write transaction, in its turn: any failure rolls back and throws a {@link StoreError} naming the operation.
+  _tx(operation, work) {
+    return this._serial(async () => {
+      const tx = await this._begin(operation);
+      try {
+        const result = await work(tx);
+        await tx.commit();
+        return result;
+      } catch (e) {
+        await tx.rollback();
+        throw new StoreError(operation, { cause: e });
+      }
+    });
   }
   async dispose() {
-    await Promise.resolve();
-    this.client.close();
+    await this._serial(async () => this.client.close());
   }
   // --- commit: transaction + optimistic concurrency ---
   async commit(stream, msgs, meta, expectedVersion) {
-    const tx = await this.client.transaction("write");
-    let current_version = -1;
-    try {
-      const version_row = await tx.execute({
-        sql: "SELECT COALESCE(MAX(version), -1) as v FROM events WHERE stream = ?",
-        args: [stream]
-      });
-      current_version = Number(version_row.rows[0].v);
-      if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
-        throw new ConcurrencyError(
-          stream,
-          current_version,
-          msgs,
-          expectedVersion
-        );
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const committed = [];
-      let version = current_version + 1;
-      for (const { name, data, pii } of msgs) {
-        const pii_for_write = await this._stringify_pii_for_write(pii);
-        const result = await tx.execute({
-          sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
-          args: [
+    return this._serial(async () => {
+      const tx = await this._begin("commit");
+      let current_version = -1;
+      try {
+        const version_row = await tx.execute({
+          sql: "SELECT COALESCE(MAX(version), -1) as v FROM events WHERE stream = ?",
+          args: [stream]
+        });
+        current_version = Number(version_row.rows[0].v);
+        if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
+          throw new ConcurrencyError(
+            stream,
+            current_version,
+            msgs,
+            expectedVersion
+          );
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const committed = [];
+        let version = current_version + 1;
+        for (const { name, data, pii } of msgs) {
+          const pii_for_write = await this._stringify_pii_for_write(pii);
+          const result = await tx.execute({
+            sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            args: [
+              stream,
+              version,
+              name,
+              JSON.stringify(data),
+              JSON.stringify(meta),
+              now,
+              pii_for_write
+            ]
+          });
+          committed.push({
+            id: Number(result.lastInsertRowid),
             stream,
             version,
+            created: new Date(now),
             name,
-            JSON.stringify(data),
-            JSON.stringify(meta),
-            now,
-            pii_for_write
-          ]
-        });
-        committed.push({
-          id: Number(result.lastInsertRowid),
-          stream,
-          version,
-          created: new Date(now),
-          name,
-          data,
-          meta,
-          ...pii == null ? {} : { pii }
-        });
-        version++;
+            data,
+            meta,
+            ...pii == null ? {} : { pii }
+          });
+          version++;
+        }
+        await tx.commit();
+        return committed;
+      } catch (e) {
+        await tx.rollback();
+        if (e instanceof ConcurrencyError) throw e;
+        if (is_unique_violation(e))
+          throw new ConcurrencyError(
+            stream,
+            current_version,
+            msgs,
+            expectedVersion ?? -1
+          );
+        throw new StoreError("commit", { cause: e });
       }
-      await tx.commit();
-      return committed;
-    } catch (e) {
-      await tx.rollback();
-      if (e instanceof ConcurrencyError) throw e;
-      if (is_unique_violation(e))
-        throw new ConcurrencyError(
-          stream,
-          current_version,
-          msgs,
-          expectedVersion ?? -1
-        );
-      throw new StoreError("commit", { cause: e });
-    }
+    });
   }
   // --- query: read-only, no transaction needed ---
   async query(callback, query) {
@@ -369,7 +388,7 @@ var SqliteStore = class {
       sql += " LIMIT ?";
       args.push(query.limit);
     }
-    const result = await this.client.execute({ sql, args });
+    const result = await this._exec({ sql, args });
     let count = 0;
     for (const row of result.rows) {
       const pii_value = query?.with_pii === false ? null : await this._parse_pii_from_read(row.pii);
@@ -740,8 +759,8 @@ var SqliteStore = class {
     sql += " ORDER BY stream LIMIT ?";
     args.push(limit);
     const [streamsResult, maxResult] = await Promise.all([
-      this.client.execute({ sql, args }),
-      this.client.execute("SELECT COALESCE(MAX(id), -1) AS m FROM events")
+      this._exec({ sql, args }),
+      this._exec("SELECT COALESCE(MAX(id), -1) AS m FROM events")
     ]);
     let count = 0;
     for (const row of streamsResult.rows) {
@@ -873,8 +892,8 @@ var SqliteStore = class {
         )` : null;
     const tail_args = limit !== void 0 ? [...args, ...args, limit] : [...args, ...args];
     const [headRes, tailRes] = await Promise.all([
-      this.client.execute({ sql: head_sql, args: head_args }),
-      tail_sql ? this.client.execute({ sql: tail_sql, args: tail_args }) : null
+      this._exec({ sql: head_sql, args: head_args }),
+      tail_sql ? this._exec({ sql: tail_sql, args: tail_args }) : null
     ]);
     const out = /* @__PURE__ */ new Map();
     for (const row of headRes.rows) {
@@ -936,7 +955,7 @@ var SqliteStore = class {
       ORDER BY h.stream
     `;
     const full_args = limit !== void 0 ? [...args, limit] : args;
-    const res = await this.client.execute({ sql, args: full_args });
+    const res = await this._exec({ sql, args: full_args });
     const out = /* @__PURE__ */ new Map();
     for (const row of res.rows) {
       const r = row;
@@ -1046,33 +1065,35 @@ var SqliteStore = class {
    * from the source.
    */
   async restore(driver) {
-    const tx = await this.client.transaction("write");
-    try {
-      await tx.execute("DELETE FROM events");
-      await tx.execute("DELETE FROM streams");
-      await tx.execute("UPDATE correlated SET at = -1");
-      await tx.execute("DELETE FROM sqlite_sequence WHERE name = 'events'");
-      await driver(async (event) => {
-        const pii_for_write = await this._stringify_pii_for_write(event.pii);
-        const ins = await tx.execute({
-          sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
-          args: [
-            event.stream,
-            event.version,
-            event.name,
-            JSON.stringify(event.data),
-            JSON.stringify(event.meta),
-            event.created.toISOString(),
-            pii_for_write
-          ]
+    return this._serial(async () => {
+      const tx = await this._begin("restore");
+      try {
+        await tx.execute("DELETE FROM events");
+        await tx.execute("DELETE FROM streams");
+        await tx.execute("UPDATE correlated SET at = -1");
+        await tx.execute("DELETE FROM sqlite_sequence WHERE name = 'events'");
+        await driver(async (event) => {
+          const pii_for_write = await this._stringify_pii_for_write(event.pii);
+          const ins = await tx.execute({
+            sql: "INSERT INTO events (stream, version, name, data, meta, created, pii) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            args: [
+              event.stream,
+              event.version,
+              event.name,
+              JSON.stringify(event.data),
+              JSON.stringify(event.meta),
+              event.created.toISOString(),
+              pii_for_write
+            ]
+          });
+          return Number(ins.lastInsertRowid);
         });
-        return Number(ins.lastInsertRowid);
-      });
-      await tx.commit();
-    } catch (error) {
-      await tx.rollback();
-      throw error;
-    }
+        await tx.commit();
+      } catch (error) {
+        await tx.rollback();
+        throw error;
+      }
+    });
   }
   /**
    * Wipe the sensitive-data payload for every event on the stream — the
@@ -1092,7 +1113,7 @@ var SqliteStore = class {
    * @returns Count of events whose `pii` was set to `NULL`
    */
   async forget_pii(stream) {
-    const r = await this.client.execute({
+    const r = await this._exec({
       sql: "UPDATE events SET pii = NULL WHERE stream = ? AND pii IS NOT NULL",
       args: [stream]
     });