@rotorsoft/act-sqlite 1.20.2 → 1.20.4

package/dist/index.js

@@ -654,30 +654,45 @@ 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 });
+    }
+  }
+  /**
+   * 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) {
+    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 {
       let count = 0;
-      if (Array.isArray(input)) {
-        for (const stream of new Set(input)) {
-          const r = await tx.execute({
-            sql: `UPDATE streams SET deferred_at = ?, retry = -1 WHERE stream = ?`,
-            args: [at_iso, stream]
-          });
-          count += r.rowsAffected;
-        }
-      } else {
-        const { clause, args } = this._filter_clause(input);
+      for (const { clause, args } of selections) {
         const r = await tx.execute({
-          sql: `UPDATE streams SET deferred_at = ?, retry = -1 WHERE ${clause}`,
-          args: [at_iso, ...args]
+          sql: `UPDATE streams ${set} WHERE ${where ? `${where} AND ` : ""}${clause}`,
+          args: [...params, ...args]
         });
-        count = r.rowsAffected;
+        count += r.rowsAffected;
       }
       await tx.commit();
       return count;
     } catch (e) {
       await tx.rollback();
-      throw new StoreError("defer", { cause: e });
+      throw e;
     }
   }
   /**
@@ -718,103 +733,32 @@ var SqliteStore = class {
     return { clause: conditions.length ? conditions.join(" AND ") : "1", args };
   }
   // --- reset: transactional, accepts names or filter ---
-  async reset(input) {
-    const set_clause = `SET at = -1, retry = -1, blocked = 0, error = '',
-                          leased_by = NULL, leased_until = NULL, deferred_at = NULL`;
-    const tx = await this.client.transaction("write");
-    try {
-      let count = 0;
-      if (Array.isArray(input)) {
-        for (const stream of new Set(input)) {
-          const r = await tx.execute({
-            sql: `UPDATE streams ${set_clause} WHERE stream = ?`,
-            args: [stream]
-          });
-          count += r.rowsAffected;
-        }
-      } else {
-        const { clause, args } = this._filter_clause(input);
-        const r = await tx.execute({
-          sql: `UPDATE streams ${set_clause} WHERE ${clause}`,
-          args
-        });
-        count = r.rowsAffected;
-      }
-      await tx.commit();
-      return count;
-    } catch (e) {
-      await tx.rollback();
-      throw e;
-    }
+  reset(input) {
+    return this._update(
+      input,
+      `SET at = -1, retry = -1, blocked = 0, error = '',
+           leased_by = NULL, leased_until = NULL, deferred_at = NULL`
+    );
   }
   // --- unblock: clear blocked + retry + lease without touching watermark ---
   // `retry = -1` so claim's post-bump returns retry=0 (first attempt),
-  // matching the InMemoryStore convention.
-  async unblock(input) {
-    const set_clause = `SET retry = -1, blocked = 0, error = '',
-                          leased_by = NULL, leased_until = NULL, deferred_at = NULL`;
-    const tx = await this.client.transaction("write");
-    try {
-      let count = 0;
-      if (Array.isArray(input)) {
-        for (const stream of input) {
-          const r = await tx.execute({
-            sql: `UPDATE streams ${set_clause}
-                  WHERE stream = ? AND blocked = 1`,
-            args: [stream]
-          });
-          count += r.rowsAffected;
-        }
-      } else {
-        const { clause, args } = this._filter_clause({
-          ...input,
-          blocked: true
-        });
-        const r = await tx.execute({
-          sql: `UPDATE streams ${set_clause} WHERE ${clause}`,
-          args
-        });
-        count = r.rowsAffected;
-      }
-      await tx.commit();
-      return count;
-    } catch (e) {
-      await tx.rollback();
-      throw e;
-    }
+  // matching the InMemoryStore convention. Always restricted to blocked
+  // rows, whatever the filter says: there is no use case for "unblock
+  // unblocked streams."
+  unblock(input) {
+    return this._update(
+      Array.isArray(input) ? input : { ...input, blocked: void 0 },
+      `SET retry = -1, blocked = 0, error = '',
+           leased_by = NULL, leased_until = NULL, deferred_at = NULL`,
+      [],
+      "blocked = 1"
+    );
   }
   // --- query_streams: read-only introspection with filters ---
   async query_streams(callback, query) {
     const limit = query?.limit ?? 100;
-    let sql = "SELECT stream, source, at, retry, blocked, error, leased_by, leased_until, priority, lane, deferred_at, correlated_at FROM streams WHERE 1=1";
-    const args = [];
-    if (query?.stream !== void 0) {
-      if (query.stream_exact) {
-        sql += " AND stream = ?";
-        args.push(query.stream);
-      } else {
-        sql += " AND stream GLOB ?";
-        args.push(streamPatternToGlob(query.stream));
-      }
-    }
-    if (query?.source !== void 0) {
-      sql += " AND source IS NOT NULL";
-      if (query.source_exact) {
-        sql += " AND source = ?";
-        args.push(query.source);
-      } else {
-        sql += " AND source GLOB ?";
-        args.push(streamPatternToGlob(query.source));
-      }
-    }
-    if (query?.blocked !== void 0) {
-      sql += " AND blocked = ?";
-      args.push(query.blocked ? 1 : 0);
-    }
-    if (query?.lane !== void 0) {
-      sql += " AND lane = ?";
-      args.push(query.lane);
-    }
+    const { clause, args } = this._filter_clause(query ?? {});
+    let sql = `SELECT stream, source, at, retry, blocked, error, leased_by, leased_until, priority, lane, deferred_at, correlated_at FROM streams WHERE ${clause}`;
     if (query?.after !== void 0) {
       sql += " AND stream > ?";
       args.push(query.after);
@@ -1073,15 +1017,13 @@ var SqliteStore = class {
     return out;
   }
   // --- prioritize: bulk priority update with filter ---
-  async prioritize(filter, priority) {
-    const { clause, args: filterArgs } = this._filter_clause(filter);
-    const sql = `UPDATE streams SET priority = ?
-                 WHERE priority <> ? AND ${clause}`;
-    const result = await this.client.execute({
-      sql,
-      args: [priority, priority, ...filterArgs]
-    });
-    return result.rowsAffected;
+  prioritize(filter, priority) {
+    return this._update(
+      filter,
+      "SET priority = ?",
+      [priority, priority],
+      "priority <> ?"
+    );
   }
   // --- truncate: transactional delete + seed ---
   // Windowed targets (`before` set) prune the prefix below the closest safe