@rotorsoft/act-pg 0.23.0 → 0.25.0

package/dist/index.js

@@ -175,13 +175,18 @@ var PostgresStore = class {
           error text,
           leased_by text,
           leased_until timestamptz,
-          priority int NOT NULL DEFAULT 0
+          priority int NOT NULL DEFAULT 0,
+          lane text NOT NULL DEFAULT 'default'
         ) TABLESPACE pg_default;`
       );
       await client.query(
         `ALTER TABLE ${this._fqs}
          ADD COLUMN IF NOT EXISTS priority int NOT NULL DEFAULT 0;`
       );
+      await client.query(
+        `ALTER TABLE ${this._fqs}
+         ADD COLUMN IF NOT EXISTS lane text NOT NULL DEFAULT 'default';`
+      );
       await client.query(
         `DROP INDEX IF EXISTS "${this.config.schema}"."${this.config.table}_streams_fetch_ix"`
       );
@@ -189,6 +194,10 @@ var PostgresStore = class {
         `CREATE INDEX IF NOT EXISTS "${this.config.table}_streams_claim_ix"
         ON ${this._fqs} (blocked, priority DESC, at);`
       );
+      await client.query(
+        `CREATE INDEX IF NOT EXISTS "${this.config.table}_streams_lane_ix"
+        ON ${this._fqs} (lane);`
+      );
       await client.query("COMMIT");
       logger.info(
         `Seeded schema "${this.config.schema}" with table "${this.config.table}"`
@@ -386,17 +395,20 @@ var PostgresStore = class {
    * @param millis - Lease duration in milliseconds
    * @returns Leased streams with metadata
    */
-  async claim(lagging, leading, by, millis) {
+  async claim(lagging, leading, by, millis, lane) {
     const client = await this._pool.connect();
     try {
       await client.query("BEGIN");
+      const laneClause = lane !== void 0 ? `AND s.lane = $5` : "";
+      const params = lane !== void 0 ? [lagging, leading, by, millis, lane] : [lagging, leading, by, millis];
       const { rows } = await client.query(
         `
         WITH
         available AS (
-          SELECT stream, source, at, priority
+          SELECT stream, source, at, priority, lane
           FROM ${this._fqs} s
           WHERE blocked = false
+            ${laneClause}
             AND (leased_by IS NULL OR leased_until <= NOW())
             AND (s.at < 0 OR EXISTS (
               SELECT 1 FROM ${this._fqt} e
@@ -412,19 +424,19 @@ var PostgresStore = class {
         -- ORDER BY collapses to plain at ASC so existing workloads
         -- see no behavior change.
         lag AS (
-          SELECT stream, source, at, TRUE AS lagging
+          SELECT stream, source, at, lane, TRUE AS lagging
           FROM available
           ORDER BY priority DESC, at ASC
           LIMIT $1
         ),
         lead AS (
-          SELECT stream, source, at, FALSE AS lagging
+          SELECT stream, source, at, lane, FALSE AS lagging
           FROM available
           ORDER BY at DESC
           LIMIT $2
         ),
         combined AS (
-          SELECT DISTINCT ON (stream) stream, source, at, lagging
+          SELECT DISTINCT ON (stream) stream, source, at, lane, lagging
           FROM (SELECT * FROM lag UNION ALL SELECT * FROM lead) t
           ORDER BY stream, at
         )
@@ -435,18 +447,19 @@ var PostgresStore = class {
           retry = s.retry + 1
         FROM combined c
         WHERE s.stream = c.stream
-        RETURNING s.stream, s.source, s.at, s.retry, c.lagging
+        RETURNING s.stream, s.source, s.at, s.retry, c.lagging, s.lane
         `,
-        [lagging, leading, by, millis]
+        params
       );
       await client.query("COMMIT");
-      return rows.map(({ stream, source, at, retry, lagging: lagging2 }) => ({
+      return rows.map(({ stream, source, at, retry, lagging: lagging2, lane: lane2 }) => ({
         stream,
         source: source ?? void 0,
         at,
         by,
         retry,
-        lagging: lagging2
+        lagging: lagging2,
+        lane: lane2
       }));
     } catch (error) {
       await client.query("ROLLBACK").catch(() => {
@@ -472,10 +485,11 @@ var PostgresStore = class {
       if (streams.length) {
         const { rowCount: inserted } = await client.query(
           `
-          INSERT INTO ${this._fqs} (stream, source, priority)
+          INSERT INTO ${this._fqs} (stream, source, priority, lane)
           SELECT s->>'stream',
                  s->>'source',
-                 COALESCE((s->>'priority')::int, 0)
+                 COALESCE((s->>'priority')::int, 0),
+                 COALESCE(s->>'lane', 'default')
           FROM jsonb_array_elements($1::jsonb) AS s
           ON CONFLICT (stream) DO NOTHING
           `,
@@ -492,6 +506,16 @@ var PostgresStore = class {
           `,
           [JSON.stringify(streams)]
         );
+        await client.query(
+          `
+          UPDATE ${this._fqs} t
+          SET lane = COALESCE(s->>'lane', 'default')
+          FROM jsonb_array_elements($1::jsonb) AS s
+          WHERE t.stream = s->>'stream'
+            AND t.lane <> COALESCE(s->>'lane', 'default')
+          `,
+          [JSON.stringify(streams)]
+        );
       }
       const { rows } = await client.query(
         `SELECT COALESCE(MAX(at), -1) AS max FROM ${this._fqs}`
@@ -531,7 +555,7 @@ var PostgresStore = class {
         leased_until = NULL
       FROM input i
       WHERE s.stream = i.stream AND s.leased_by = i.by
-      RETURNING s.stream, s.source, s.at, i.by, s.retry, i.lagging
+      RETURNING s.stream, s.source, s.at, i.by, s.retry, i.lagging, s.lane
       `,
         [JSON.stringify(leases)]
       );
@@ -542,7 +566,8 @@ var PostgresStore = class {
         at: row.at,
         by: row.by,
         retry: row.retry,
-        lagging: row.lagging
+        lagging: row.lagging,
+        lane: row.lane
       }));
     } catch (error) {
       await client.query("ROLLBACK").catch(() => {
@@ -572,7 +597,7 @@ var PostgresStore = class {
       SET blocked = true, error = i.error
       FROM input i
       WHERE s.stream = i.stream AND s.leased_by = i.by AND s.blocked = false
-      RETURNING s.stream, s.source, s.at, i.by, s.retry, s.error, i.lagging
+      RETURNING s.stream, s.source, s.at, i.by, s.retry, s.error, i.lagging, s.lane
       `,
         [JSON.stringify(leases)]
       );
@@ -584,7 +609,8 @@ var PostgresStore = class {
         by: row.by,
         retry: row.retry,
         lagging: row.lagging,
-        error: row.error
+        error: row.error,
+        lane: row.lane
       }));
     } catch (error) {
       await client.query("ROLLBACK").catch(() => {
@@ -627,6 +653,10 @@ var PostgresStore = class {
       values.push(filter.blocked);
       conditions.push(`blocked = $${start + values.length - 1}`);
     }
+    if (filter.lane !== void 0) {
+      values.push(filter.lane);
+      conditions.push(`lane = $${start + values.length - 1}`);
+    }
     return {
       clause: conditions.length ? conditions.join(" AND ") : "TRUE",
       values
@@ -739,11 +769,15 @@ var PostgresStore = class {
       values.push(query.blocked);
       conditions.push(`blocked = $${values.length}`);
     }
+    if (query?.lane !== void 0) {
+      values.push(query.lane);
+      conditions.push(`lane = $${values.length}`);
+    }
     if (query?.after !== void 0) {
       values.push(query.after);
       conditions.push(`stream > $${values.length}`);
     }
-    let sql = `SELECT stream, source, at, retry, blocked, error, leased_by, leased_until, priority FROM ${this._fqs}`;
+    let sql = `SELECT stream, source, at, retry, blocked, error, leased_by, leased_until, priority, lane FROM ${this._fqs}`;
     if (conditions.length) sql += " WHERE " + conditions.join(" AND ");
     values.push(limit);
     sql += ` ORDER BY stream LIMIT $${values.length}`;
@@ -766,7 +800,8 @@ var PostgresStore = class {
           error: row.error ?? "",
           priority: row.priority,
           leased_by: row.leased_by ?? void 0,
-          leased_until: row.leased_until ?? void 0
+          leased_until: row.leased_until ?? void 0,
+          lane: row.lane
         });
         count++;
       }
@@ -775,6 +810,168 @@ var PostgresStore = class {
       client.release();
     }
   }
+  /**
+   * Per-stream aggregated stats — see {@link Store.query_stats}.
+   *
+   * Two code paths chosen by the requested stats:
+   *
+   * - **Heads-only path** (no `count`, no `names`): one or two
+   *   `SELECT DISTINCT ON (stream) ... ORDER BY stream, version DESC|ASC`
+   *   queries, executed in parallel when `tail: true`. The
+   *   `(stream, version)` unique index gives index-only access — K rows
+   *   touched per query (K = matched streams), not N (events).
+   *   Ordering by `version` (not `id`) is equivalent within a stream
+   *   (versions are monotonic per stream and events are committed
+   *   sequentially) and is the column actually indexed.
+   *
+   * - **Full-scan path** (`count` or `names` set): one CTE materializes
+   *   the filtered events, then `GROUP BY stream, name` →
+   *   `jsonb_object_agg(name, n)` for the `names` map plus per-stream
+   *   `COUNT(*)` for `count`. Heads (and `tails` when requested) come
+   *   from `DISTINCT ON` over the same CTE — they ride free on the
+   *   already-paid scan.
+   *
+   * The stream universe is derived from the events table: filter form
+   * matches event-bearing streams (not subscription rows). When the
+   * filter sets `source` or `blocked`, the events table is joined
+   * against the streams subscription table since those concepts only
+   * exist for subscribed streams.
+   */
+  async query_stats(input, options) {
+    const exclude = options?.exclude ?? [];
+    const wantTail = options?.tail ?? false;
+    const wantCount = options?.count ?? false;
+    const wantNames = options?.names ?? false;
+    const before = options?.before;
+    const fullScan = wantCount || wantNames;
+    if (Array.isArray(input) && input.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const where = [];
+    const params = [];
+    if (Array.isArray(input)) {
+      params.push(input);
+      where.push(`e.stream = ANY($${params.length})`);
+    } else if (input.stream !== void 0) {
+      params.push(input.stream);
+      where.push(
+        input.stream_exact ? `e.stream = $${params.length}` : `e.stream ~ $${params.length}`
+      );
+    }
+    if (exclude.length) {
+      params.push(exclude);
+      where.push(`e.name <> ALL($${params.length})`);
+    }
+    if (before !== void 0) {
+      params.push(before);
+      where.push(`e.id < $${params.length}`);
+    }
+    const fromClause = `${this._fqt} e`;
+    const whereClause = `WHERE ${where.length ? where.join(" AND ") : "TRUE"}`;
+    return fullScan ? this._queryStatsFullScan(
+      fromClause,
+      whereClause,
+      params,
+      wantTail,
+      wantCount,
+      wantNames
+    ) : this._queryStatsHeadsOnly(fromClause, whereClause, params, wantTail);
+  }
+  /**
+   * Cheap path: index-only DISTINCT ON for the head per stream, plus an
+   * optional second query (in parallel) for the tail. K rows touched
+   * per query, not N events.
+   */
+  async _queryStatsHeadsOnly(fromClause, whereClause, params, wantTail) {
+    const cols = `e.id, e.stream, e.version, e.name, e.data, e.created, e.meta`;
+    const headSql = `SELECT DISTINCT ON (e.stream) ${cols} FROM ${fromClause} ${whereClause} ORDER BY e.stream, e.version DESC`;
+    const tailSql = wantTail ? `SELECT DISTINCT ON (e.stream) ${cols} FROM ${fromClause} ${whereClause} ORDER BY e.stream, e.version ASC` : null;
+    const [headRes, tailRes] = await Promise.all([
+      this._pool.query(headSql, params),
+      tailSql ? this._pool.query(tailSql, params) : Promise.resolve(null)
+    ]);
+    const out = /* @__PURE__ */ new Map();
+    for (const row of headRes.rows) {
+      out.set(row.stream, { head: row });
+    }
+    if (tailRes) {
+      for (const row of tailRes.rows) {
+        out.get(row.stream).tail = row;
+      }
+    }
+    return out;
+  }
+  /**
+   * Full-scan path: one CTE-based query computes the per-stream
+   * `COUNT(*)` and `jsonb_object_agg(name, n)` map alongside the head
+   * (and tail when requested). All extras share the single events scan.
+   */
+  async _queryStatsFullScan(fromClause, whereClause, params, wantTail, wantCount, wantNames) {
+    const tailCte = wantTail ? `, tails AS (SELECT DISTINCT ON (stream) * FROM ef ORDER BY stream, version ASC)` : "";
+    const tailJoin = wantTail ? `LEFT JOIN tails t ON t.stream = h.stream` : "";
+    const tailCols = wantTail ? `, t.id AS t_id, t.stream AS t_stream, t.version AS t_version,
+           t.name AS t_name, t.data AS t_data, t.created AS t_created, t.meta AS t_meta` : "";
+    const sql = `
+      WITH ef AS (
+        SELECT e.id, e.stream, e.version, e.name, e.data, e.created, e.meta
+        FROM ${fromClause}
+        ${whereClause}
+      ),
+      agg AS (
+        SELECT stream,
+               SUM(n)::int AS cnt,
+               jsonb_object_agg(name, n) AS names
+        FROM (
+          SELECT stream, name, COUNT(*)::int AS n
+          FROM ef
+          GROUP BY stream, name
+        ) t
+        GROUP BY stream
+      ),
+      heads AS (
+        SELECT DISTINCT ON (stream) * FROM ef ORDER BY stream, version DESC
+      )
+      ${tailCte}
+      SELECT
+        h.id, h.stream, h.version, h.name, h.data, h.created, h.meta,
+        a.cnt AS agg_count,
+        a.names AS agg_names
+        ${tailCols}
+      FROM heads h
+      LEFT JOIN agg a ON a.stream = h.stream
+      ${tailJoin}
+    `;
+    const res = await this._pool.query(sql, params);
+    const out = /* @__PURE__ */ new Map();
+    for (const row of res.rows) {
+      const stats = {
+        head: {
+          id: row.id,
+          stream: row.stream,
+          version: row.version,
+          name: row.name,
+          data: row.data,
+          created: row.created,
+          meta: row.meta
+        }
+      };
+      if (wantTail && row.t_id !== void 0 && row.t_id !== null) {
+        stats.tail = {
+          id: row.t_id,
+          stream: row.t_stream,
+          version: row.t_version,
+          name: row.t_name,
+          data: row.t_data,
+          created: row.t_created,
+          meta: row.t_meta
+        };
+      }
+      if (wantCount) stats.count = row.agg_count;
+      if (wantNames) stats.names = row.agg_names;
+      out.set(row.stream, stats);
+    }
+    return out;
+  }
   /**
    * Implementation of the optional `Store.notify` hook. Bound onto
    * `this.notify` in the constructor when `config.notify === true`,