@rotorsoft/act-sqlite 1.22.3 → 1.22.5

package/dist/index.cjs

@@ -97,13 +97,11 @@ function streamPatternToGlob(input) {
 }
 var SqliteStore = class {
   client;
-  /**
-   * Memoized key resolver for the optional `pii_encryption` envelope.
-   * Initialized in the constructor when encryption is configured;
-   * `undefined` otherwise. The resolver caches the operator's key on
-   * first use — rotation means restarting the store with a fresh
-   * provider.
-   */
+  // Memoized key resolver for the optional `pii_encryption` envelope.
+  // Initialized in the constructor when encryption is configured;
+  // `undefined` otherwise. The resolver caches the operator's key on
+  // first use — rotation means restarting the store with a fresh
+  // provider.
   _resolve_pii_key;
   constructor(config) {
     this.client = (0, import_client.createClient)({
@@ -112,14 +110,10 @@ var SqliteStore = class {
     });
     this._resolve_pii_key = config.pii_encryption ? (0, import_act_crypto.makeKeyResolver)(config.pii_encryption) : void 0;
   }
-  /**
-   * Write-side pii encoder: encrypts when `pii_encryption` is configured,
-   * stringifies for the TEXT column either way. `null` passes through so
-   * `forget_pii` semantics survive intact (the row format skips the
-   * column entirely on a `NULL` write).
-   *
-   * @internal
-   */
+  // Write-side pii encoder: encrypts when `pii_encryption` is configured,
+  // stringifies for the TEXT column either way. `null` passes through so
+  // `forget_pii` semantics survive intact (the row format skips the
+  // column entirely on a `NULL` write).
   async _stringify_pii_for_write(pii) {
     if (pii == null) return null;
     if (this._resolve_pii_key) {
@@ -127,15 +121,11 @@ var SqliteStore = class {
     }
     return JSON.stringify(pii);
   }
-  /**
-   * Read-side pii decoder: parses the TEXT column, and when
-   * `pii_encryption` is configured, transparently decrypts any value
-   * that came back as a JSON string. Plaintext writes deserialize to
-   * objects and pass through — which is what makes mixed-data
-   * rollouts (some pre-encryption rows, some post-) read cleanly.
-   *
-   * @internal
-   */
+  // Read-side pii decoder: parses the TEXT column, and when
+  // `pii_encryption` is configured, transparently decrypts any value
+  // that came back as a JSON string. Plaintext writes deserialize to
+  // objects and pass through — which is what makes mixed-data
+  // rollouts (some pre-encryption rows, some post-) read cleanly.
   async _parse_pii_from_read(raw) {
     if (raw == null) return null;
     const parsed = parse_json(raw);
@@ -145,8 +135,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,
@@ -160,22 +150,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,
@@ -192,40 +182,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,
@@ -233,15 +219,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,
@@ -250,104 +234,121 @@ 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();
-      throw new import_act.StoreError(operation, { cause: e });
-    }
+  // 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));
+  }
+  // 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.client.transaction("write");
+      try {
+        const result = await work(tx);
+        await tx.commit();
+        return result;
+      } catch (e) {
+        await tx.rollback();
+        throw new import_act.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 import_act.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.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 import_act.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 import_act.ConcurrencyError) throw e;
+        if (is_unique_violation(e))
+          throw new import_act.ConcurrencyError(
+            stream,
+            current_version,
+            msgs,
+            expectedVersion ?? -1
+          );
+        throw new import_act.StoreError("commit", { cause: e });
       }
-      await tx.commit();
-      return committed;
-    } catch (e) {
-      await tx.rollback();
-      if (e instanceof import_act.ConcurrencyError) throw e;
-      if (is_unique_violation(e))
-        throw new import_act.ConcurrencyError(
-          stream,
-          current_version,
-          msgs,
-          expectedVersion ?? -1
-        );
-      throw new import_act.StoreError("commit", { cause: e });
-    }
+    });
   }
   // --- query: read-only, no transaction needed ---
   async query(callback, query) {
@@ -397,7 +398,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);
@@ -671,17 +672,15 @@ var SqliteStore = class {
       at_iso
     ]);
   }
-  /**
-   * Runs `UPDATE streams <set>` on the streams named by `input`, in one
-   * write transaction (`_tx`) that rolls back on failure. An explicit list is
-   * de-duplicated, so a repeated name counts once (matching PG's set-based
-   * `stream = ANY(...)`), and updated one name per statement, so a long list
-   * never meets SQLite's bound-parameter limit. `set` and `where` bind
-   * `params` in order; libSQL `?` placeholders are positional and can't be
-   * reused, so a value used twice is passed twice.
-   *
-   * @returns Count of rows updated.
-   */
+  // Runs `UPDATE streams <set>` on the streams named by `input`, in one
+  // write transaction (`_tx`) that rolls back on failure. An explicit list is
+  // de-duplicated, so a repeated name counts once (matching PG's set-based
+  // `stream = ANY(...)`), and updated one name per statement, so a long list
+  // never meets SQLite's bound-parameter limit. `set` and `where` bind
+  // `params` in order; libSQL `?` placeholders are positional and can't be
+  // reused, so a value used twice is passed twice.
+  //
+  // @returns Count of rows updated.
   _update(operation, input, set, params = [], where) {
     const selections = Array.isArray(input) ? [...new Set(input)].map((stream) => ({
       clause: "stream = ?",
@@ -699,11 +698,9 @@ var SqliteStore = class {
       return count;
     });
   }
-  /**
-   * Translate a {@link StreamFilter} to a SQLite `WHERE` clause fragment
-   * plus positional args. Returns `"1"` (always true) when empty so
-   * callers can compose it unconditionally.
-   */
+  // Translate a {@link StreamFilter} to a SQLite `WHERE` clause fragment
+  // plus positional args. Returns `"1"` (always true) when empty so
+  // callers can compose it unconditionally.
   _filter_clause(filter) {
     const conditions = [];
     const args = [];
@@ -772,8 +769,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) {
@@ -880,10 +877,8 @@ var SqliteStore = class {
       limit
     );
   }
-  /**
-   * Cheap path — head (and optional tail) via ROW_NUMBER() over the
-   * `(stream, version)` unique index. Parallel queries when tail set.
-   */
+  // Cheap path — head (and optional tail) via ROW_NUMBER() over the
+  // `(stream, version)` unique index. Parallel queries when tail set.
   async _query_stats_heads_only(from_clause, where_clause, args, want_tail, limit) {
     const cols = `e.id, e.stream, e.version, e.name, e.data, e.created, e.meta`;
     const limit_clause = limit !== void 0 ? " LIMIT ?" : "";
@@ -907,8 +902,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) {
@@ -923,11 +918,9 @@ var SqliteStore = class {
     }
     return out;
   }
-  /**
-   * Full-scan path — one CTE-based query with per-stream `COUNT(*)` and
-   * `json_group_object(name, n)`. Heads (and optional tails) ride free
-   * on the same scan.
-   */
+  // Full-scan path — one CTE-based query with per-stream `COUNT(*)` and
+  // `json_group_object(name, n)`. Heads (and optional tails) ride free
+  // on the same scan.
   async _query_stats_full_scan(from_clause, where_clause, args, want_tail, want_count, want_names, limit) {
     const tail_cte = want_tail ? `, tails AS (
           SELECT * FROM (
@@ -972,7 +965,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;
@@ -1082,33 +1075,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.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 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
@@ -1128,7 +1123,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]
     });