@rotorsoft/act-sqlite 1.22.2 → 1.22.4

package/dist/index.js

@@ -79,13 +79,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 = createClient({
@@ -94,14 +92,10 @@ var SqliteStore = class {
     });
     this._resolve_pii_key = config.pii_encryption ? 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) {
@@ -109,15 +103,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);
@@ -253,7 +243,7 @@ var SqliteStore = class {
     await this.client.execute("DROP TABLE IF EXISTS streams");
     await this.client.execute("DROP TABLE IF EXISTS correlated");
   }
-  /** One write transaction: any failure rolls back and throws a {@link StoreError} naming the operation. */
+  // 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 {
@@ -649,32 +639,25 @@ var SqliteStore = class {
   // Cleared by ack/block/reset/unblock. See {@link Store.defer}.
   async defer(input, deferred_at) {
     const at_iso = new Date(deferred_at).toISOString();
-    try {
-      return await this._update(input, "SET deferred_at = ?, retry = -1", [
-        at_iso
-      ]);
-    } catch (e) {
-      throw new StoreError("defer", { cause: e });
-    }
+    return this._update("defer", input, "SET deferred_at = ?, retry = -1", [
+      at_iso
+    ]);
   }
-  /**
-   * Runs `UPDATE streams <set>` on the streams named by `input`, in one
-   * write transaction 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.
-   */
-  async _update(input, set, params = [], where) {
+  // 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 = ?",
       args: [stream]
     })) : [this._filter_clause(input)];
-    const tx = await this.client.transaction("write");
-    try {
+    return this._tx(operation, async (tx) => {
       let count = 0;
       for (const { clause, args } of selections) {
         const r = await tx.execute({
@@ -683,18 +666,12 @@ var SqliteStore = class {
         });
         count += r.rowsAffected;
       }
-      await tx.commit();
       return count;
-    } catch (e) {
-      await tx.rollback();
-      throw e;
-    }
+    });
   }
-  /**
-   * 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 = [];
@@ -730,6 +707,7 @@ var SqliteStore = class {
   // --- reset: transactional, accepts names or filter ---
   reset(input) {
     return this._update(
+      "reset",
       input,
       `SET at = -1, retry = -1, blocked = 0, error = '',
            leased_by = NULL, leased_until = NULL, deferred_at = NULL`
@@ -742,6 +720,7 @@ var SqliteStore = class {
   // unblocked streams."
   unblock(input) {
     return this._update(
+      "unblock",
       Array.isArray(input) ? input : { ...input, blocked: void 0 },
       `SET retry = -1, blocked = 0, error = '',
            leased_by = NULL, leased_until = NULL, deferred_at = NULL`,
@@ -869,10 +848,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 ?" : "";
@@ -912,11 +889,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 (
@@ -980,6 +955,7 @@ var SqliteStore = class {
   // --- prioritize: bulk priority update with filter ---
   prioritize(filter, priority) {
     return this._update(
+      "prioritize",
       filter,
       "SET priority = ?",
       [priority, priority],