@rotorsoft/act-pg 1.4.0 → 1.4.2

package/dist/index.js

@@ -27,10 +27,10 @@ types.setTypeParser(
 var SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var PG_UNIQUE_VIOLATION = "23505";
 var NOTIFY_CHANNEL_PREFIX = "act_commit";
-function notifyChannel(schema, table) {
+function notify_channel(schema, table) {
   return `${NOTIFY_CHANNEL_PREFIX}_${schema}_${table}`;
 }
-function assertSafeIdentifier(value, label) {
+function assert_safe_identifier(value, label) {
   if (!SAFE_IDENTIFIER.test(value))
     throw new Error(`Unsafe SQL identifier for ${label}: "${value}"`);
 }
@@ -63,14 +63,14 @@ var PostgresStore = class {
    */
   _channel;
   /** Active LISTEN client (one per `notify()` subscription). */
-  _listenClient;
+  _listen_client;
   /**
    * Notification listener attached to the active LISTEN client. Tracked
    * separately so the re-subscribe / dispose paths can detach it before
    * destroying the client — without this, a pool that reused the
    * connection would re-fire the stale handler.
    */
-  _listenHandler;
+  _listen_handler;
   /**
    * Cross-process commit subscription. **Present only when
    * `config.notify === true`** — the orchestrator's auto-wire path
@@ -88,15 +88,15 @@ var PostgresStore = class {
    */
   constructor(config = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    assertSafeIdentifier(this.config.schema, "schema");
-    assertSafeIdentifier(this.config.table, "table");
+    assert_safe_identifier(this.config.schema, "schema");
+    assert_safe_identifier(this.config.table, "table");
     const { schema: _, table: __, ...poolConfig } = this.config;
     this._pool = new Pool(poolConfig);
     this._fqt = `"${this.config.schema}"."${this.config.table}"`;
     this._fqs = `"${this.config.schema}"."${this.config.table}_streams"`;
-    this._channel = notifyChannel(this.config.schema, this.config.table);
+    this._channel = notify_channel(this.config.schema, this.config.table);
     if (this.config.notify) {
-      this.notify = this._subscribeNotifications.bind(this);
+      this.notify = this._subscribe_notifications.bind(this);
     }
   }
   /**
@@ -105,7 +105,7 @@ var PostgresStore = class {
    * @returns Promise that resolves when all connections are closed
    */
   async dispose() {
-    await this._teardownListen();
+    await this._teardown_listen();
     await this._pool.end();
   }
   /**
@@ -115,16 +115,16 @@ var PostgresStore = class {
    * destroying belt-and-braces guards against any future change in
    * pg-pool semantics that could re-issue a half-clean client).
    */
-  async _teardownListen() {
-    if (!this._listenClient) return;
-    this._listenClient.removeListener("notification", this._listenHandler);
-    this._listenHandler = void 0;
+  async _teardown_listen() {
+    if (!this._listen_client) return;
+    this._listen_client.removeListener("notification", this._listen_handler);
+    this._listen_handler = void 0;
     try {
-      await this._listenClient.query(`UNLISTEN ${this._channel}`);
+      await this._listen_client.query(`UNLISTEN ${this._channel}`);
     } catch {
     }
-    this._listenClient.release(true);
-    this._listenClient = void 0;
+    this._listen_client.release(true);
+    this._listen_client = void 0;
   }
   /**
    * Seed the database with required tables, indexes, and schema for event storage.
@@ -146,9 +146,13 @@ var PostgresStore = class {
           stream varchar(100) COLLATE pg_catalog."default" NOT NULL,
           version int NOT NULL,
           created timestamptz NOT NULL DEFAULT now(),
-          meta jsonb
+          meta jsonb,
+          pii jsonb
         ) TABLESPACE pg_default;`
       );
+      await client.query(
+        `ALTER TABLE ${this._fqt} ADD COLUMN IF NOT EXISTS pii jsonb;`
+      );
       await client.query(
         `CREATE UNIQUE INDEX IF NOT EXISTS "${this.config.table}_stream_ix" 
         ON ${this._fqt} (stream COLLATE pg_catalog."default", version);`
@@ -339,12 +343,12 @@ var PostgresStore = class {
           expectedVersion
         );
       const committed = [];
-      for (const { name, data } of msgs) {
+      for (const { name, data, pii } of msgs) {
         version++;
         const sql = `
-          INSERT INTO ${this._fqt}(name, data, stream, version, meta)
-          VALUES($1, $2, $3, $4, $5) RETURNING *`;
-        const vals = [name, data, stream, version, meta];
+          INSERT INTO ${this._fqt}(name, data, pii, stream, version, meta)
+          VALUES($1, $2, $3, $4, $5, $6) RETURNING *`;
+        const vals = [name, data, pii ?? null, stream, version, meta];
         try {
           const { rows } = await client.query(sql, vals);
           committed.push(rows.at(0));
@@ -399,7 +403,7 @@ var PostgresStore = class {
     const client = await this._pool.connect();
     try {
       await client.query("BEGIN");
-      const laneClause = lane !== void 0 ? `AND s.lane = $5` : "";
+      const lane_clause = 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(
         `
@@ -408,7 +412,7 @@ var PostgresStore = class {
           SELECT stream, source, at, priority, lane
           FROM ${this._fqs} s
           WHERE blocked = false
-            ${laneClause}
+            ${lane_clause}
             AND (leased_by IS NULL OR leased_until <= NOW())
             AND (s.at < 0 OR EXISTS (
               SELECT 1 FROM ${this._fqt} e
@@ -633,7 +637,7 @@ var PostgresStore = class {
    * `WHERE` — callers compose it with any other predicates they need.
    * Returns an always-true clause (`true`) when the filter is empty.
    */
-  _filterClause(filter, start) {
+  _filter_clause(filter, start) {
     const conditions = [];
     const values = [];
     if (filter.stream !== void 0) {
@@ -663,19 +667,19 @@ var PostgresStore = class {
     };
   }
   async reset(input) {
-    const setClause = `SET at = -1, retry = 0, blocked = false, error = NULL,
+    const set_clause = `SET at = -1, retry = 0, blocked = false, error = NULL,
                           leased_by = NULL, leased_until = NULL`;
     if (Array.isArray(input)) {
       if (!input.length) return 0;
       const { rowCount: rowCount2 } = await this._pool.query(
-        `UPDATE ${this._fqs} ${setClause} WHERE stream = ANY($1)`,
+        `UPDATE ${this._fqs} ${set_clause} WHERE stream = ANY($1)`,
         [input]
       );
       return rowCount2 ?? 0;
     }
-    const { clause, values } = this._filterClause(input, 1);
+    const { clause, values } = this._filter_clause(input, 1);
     const { rowCount } = await this._pool.query(
-      `UPDATE ${this._fqs} ${setClause} WHERE ${clause}`,
+      `UPDATE ${this._fqs} ${set_clause} WHERE ${clause}`,
       values
     );
     return rowCount ?? 0;
@@ -696,23 +700,23 @@ var PostgresStore = class {
    * @returns Count of streams that were actually flipped (were blocked).
    */
   async unblock(input) {
-    const setClause = `SET retry = -1, blocked = false, error = NULL,
+    const set_clause = `SET retry = -1, blocked = false, error = NULL,
                           leased_by = NULL, leased_until = NULL`;
     if (Array.isArray(input)) {
       if (!input.length) return 0;
       const { rowCount: rowCount2 } = await this._pool.query(
-        `UPDATE ${this._fqs} ${setClause}
+        `UPDATE ${this._fqs} ${set_clause}
          WHERE stream = ANY($1) AND blocked = true`,
         [input]
       );
       return rowCount2 ?? 0;
     }
-    const { clause, values } = this._filterClause(
+    const { clause, values } = this._filter_clause(
       { ...input, blocked: true },
       1
     );
     const { rowCount } = await this._pool.query(
-      `UPDATE ${this._fqs} ${setClause} WHERE ${clause}`,
+      `UPDATE ${this._fqs} ${set_clause} WHERE ${clause}`,
       values
     );
     return rowCount ?? 0;
@@ -732,7 +736,7 @@ var PostgresStore = class {
    * @returns Count of streams whose priority changed.
    */
   async prioritize(filter, priority) {
-    const { clause, values } = this._filterClause(filter, 2);
+    const { clause, values } = this._filter_clause(filter, 2);
     const sql = `UPDATE ${this._fqs} SET priority = $1
                  WHERE priority <> $1 AND ${clause}`;
     const { rowCount } = await this._pool.query(sql, [priority, ...values]);
@@ -839,11 +843,11 @@ var PostgresStore = class {
    */
   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 want_tail = options?.tail ?? false;
+    const want_count = options?.count ?? false;
+    const want_names = options?.names ?? false;
     const before = options?.before;
-    const fullScan = wantCount || wantNames;
+    const full_scan = want_count || want_names;
     if (Array.isArray(input) && input.length === 0) {
       return /* @__PURE__ */ new Map();
     }
@@ -866,29 +870,34 @@ var PostgresStore = class {
       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,
+    const from_clause = `${this._fqt} e`;
+    const where_clause = `WHERE ${where.length ? where.join(" AND ") : "TRUE"}`;
+    return full_scan ? this._query_stats_full_scan(
+      from_clause,
+      where_clause,
+      params,
+      want_tail,
+      want_count,
+      want_names
+    ) : this._query_stats_heads_only(
+      from_clause,
+      where_clause,
       params,
-      wantTail,
-      wantCount,
-      wantNames
-    ) : this._queryStatsHeadsOnly(fromClause, whereClause, params, wantTail);
+      want_tail
+    );
   }
   /**
    * 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) {
+  async _query_stats_heads_only(from_clause, where_clause, params, want_tail) {
     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 head_sql = `SELECT DISTINCT ON (e.stream) ${cols} FROM ${from_clause} ${where_clause} ORDER BY e.stream, e.version DESC`;
+    const tail_sql = want_tail ? `SELECT DISTINCT ON (e.stream) ${cols} FROM ${from_clause} ${where_clause} 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)
+      this._pool.query(head_sql, params),
+      tail_sql ? this._pool.query(tail_sql, params) : Promise.resolve(null)
     ]);
     const out = /* @__PURE__ */ new Map();
     for (const row of headRes.rows) {
@@ -906,16 +915,16 @@ var PostgresStore = class {
    * `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,
+  async _query_stats_full_scan(from_clause, where_clause, params, want_tail, want_count, want_names) {
+    const tail_cte = want_tail ? `, tails AS (SELECT DISTINCT ON (stream) * FROM ef ORDER BY stream, version ASC)` : "";
+    const tail_join = want_tail ? `LEFT JOIN tails t ON t.stream = h.stream` : "";
+    const tail_cols = want_tail ? `, 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}
+        FROM ${from_clause}
+        ${where_clause}
       ),
       agg AS (
         SELECT stream,
@@ -931,15 +940,15 @@ var PostgresStore = class {
       heads AS (
         SELECT DISTINCT ON (stream) * FROM ef ORDER BY stream, version DESC
       )
-      ${tailCte}
+      ${tail_cte}
       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}
+        ${tail_cols}
       FROM heads h
       LEFT JOIN agg a ON a.stream = h.stream
-      ${tailJoin}
+      ${tail_join}
     `;
     const res = await this._pool.query(sql, params);
     const out = /* @__PURE__ */ new Map();
@@ -955,7 +964,7 @@ var PostgresStore = class {
           meta: row.meta
         }
       };
-      if (wantTail && row.t_id !== void 0 && row.t_id !== null) {
+      if (want_tail && row.t_id !== void 0 && row.t_id !== null) {
         stats.tail = {
           id: row.t_id,
           stream: row.t_stream,
@@ -966,8 +975,8 @@ var PostgresStore = class {
           meta: row.t_meta
         };
       }
-      if (wantCount) stats.count = row.agg_count;
-      if (wantNames) stats.names = row.agg_names;
+      if (want_count) stats.count = row.agg_count;
+      if (want_names) stats.names = row.agg_names;
       out.set(row.stream, stats);
     }
     return out;
@@ -993,10 +1002,10 @@ var PostgresStore = class {
    * @param handler Called for each cross-process commit notification.
    * @returns Disposer that releases the LISTEN client.
    */
-  async _subscribeNotifications(handler) {
-    await this._teardownListen();
+  async _subscribe_notifications(handler) {
+    await this._teardown_listen();
     const client = await this._pool.connect();
-    const onNotification = (msg) => {
+    const on_notification = (msg) => {
       if (msg.channel !== this._channel) return;
       if (!msg.payload) return;
       let parsed;
@@ -1033,19 +1042,19 @@ var PostgresStore = class {
         logger.error(err, "act_commit: handler threw, listener preserved");
       }
     };
-    client.on("notification", onNotification);
+    client.on("notification", on_notification);
     try {
       await client.query(`LISTEN ${this._channel}`);
     } catch (err) {
-      client.removeListener("notification", onNotification);
+      client.removeListener("notification", on_notification);
       client.release(true);
       throw err;
     }
-    this._listenClient = client;
-    this._listenHandler = onNotification;
+    this._listen_client = client;
+    this._listen_handler = on_notification;
     return async () => {
-      if (this._listenClient !== client) return;
-      await this._teardownListen();
+      if (this._listen_client !== client) return;
+      await this._teardown_listen();
     };
   }
   /**
@@ -1116,11 +1125,12 @@ var PostgresStore = class {
       await client.query(`TRUNCATE TABLE ${this._fqs}`);
       await driver(async (event) => {
         const { rows } = await client.query(
-          `INSERT INTO ${this._fqt}(name, data, stream, version, created, meta)
-           VALUES($1, $2, $3, $4, $5, $6) RETURNING id`,
+          `INSERT INTO ${this._fqt}(name, data, pii, stream, version, created, meta)
+           VALUES($1, $2, $3, $4, $5, $6, $7) RETURNING id`,
           [
             event.name,
             event.data,
+            event.pii ?? null,
             event.stream,
             event.version,
             event.created,
@@ -1138,6 +1148,29 @@ var PostgresStore = class {
       client.release();
     }
   }
+  /**
+   * Wipe the sensitive-data payload for every event on the stream — the
+   * physical-erasure side of the sensitive-data epic (#566). Sets
+   * `events.pii` to `NULL` for the stream's events; `events.data` and
+   * the rest of the row are never touched.
+   *
+   * Row-level locks (no table lock), bounded by events-per-stream.
+   * Idempotent — a second call on an already-wiped stream returns `0`.
+   *
+   * Disk reclamation is autovacuum-driven; for strict-deletion
+   * jurisdictions the production checklist documents `VACUUM FULL` as
+   * the operator step.
+   *
+   * @param stream Target stream
+   * @returns Count of events whose `pii` was set to `NULL`
+   */
+  async forget_pii(stream) {
+    const r = await this._pool.query(
+      `UPDATE ${this._fqt} SET pii = NULL WHERE stream = $1 AND pii IS NOT NULL`,
+      [stream]
+    );
+    return r.rowCount ?? 0;
+  }
 };
 export {
   PostgresStore