@rotorsoft/act-pg 1.4.0 → 1.4.2

package/dist/@types/postgres-store.d.ts

@@ -155,14 +155,14 @@ export declare class PostgresStore implements Store {
      */
     private readonly _channel;
     /** Active LISTEN client (one per `notify()` subscription). */
-    private _listenClient;
+    private _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.
      */
-    private _listenHandler;
+    private _listen_handler;
     /**
      * Cross-process commit subscription. **Present only when
      * `config.notify === true`** — the orchestrator's auto-wire path
@@ -192,7 +192,7 @@ export declare class PostgresStore implements Store {
      * destroying belt-and-braces guards against any future change in
      * pg-pool semantics that could re-issue a half-clean client).
      */
-    private _teardownListen;
+    private _teardown_listen;
     /**
      * Seed the database with required tables, indexes, and schema for event storage.
      * @returns Promise that resolves when seeding is complete
@@ -282,7 +282,7 @@ export declare class PostgresStore implements Store {
      * `WHERE` — callers compose it with any other predicates they need.
      * Returns an always-true clause (`true`) when the filter is empty.
      */
-    private _filterClause;
+    private _filter_clause;
     reset(input: string[] | StreamFilter): Promise<number>;
     /**
      * Clear blocked flag (and retry / error / lease state) on streams
@@ -359,13 +359,13 @@ export declare class PostgresStore implements Store {
      * optional second query (in parallel) for the tail. K rows touched
      * per query, not N events.
      */
-    private _queryStatsHeadsOnly;
+    private _query_stats_heads_only;
     /**
      * 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.
      */
-    private _queryStatsFullScan;
+    private _query_stats_full_scan;
     /**
      * Implementation of the optional `Store.notify` hook. Bound onto
      * `this.notify` in the constructor when `config.notify === true`,
@@ -387,7 +387,7 @@ export declare class PostgresStore implements Store {
      * @param handler Called for each cross-process commit notification.
      * @returns Disposer that releases the LISTEN client.
      */
-    private _subscribeNotifications;
+    private _subscribe_notifications;
     /**
      * Atomically truncates streams and seeds each with a snapshot or tombstone.
      * @param targets - Streams to truncate with optional snapshot state and meta.
@@ -414,6 +414,23 @@ export declare class PostgresStore implements Store {
      * from 1. `created` is preserved verbatim from the source.
      */
     restore(driver: (callback: (event: Committed<Schemas, keyof Schemas>) => Promise<number>) => Promise<void>): Promise<void>;
+    /**
+     * 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`
+     */
+    forget_pii(stream: string): Promise<number>;
 }
 export {};
 //# sourceMappingURL=postgres-store.d.ts.map

package/dist/@types/postgres-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-store.d.ts","sourceRoot":"","sources":["../../src/postgres-store.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"postgres-store.d.ts","sourceRoot":"","sources":["../../src/postgres-store.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -58,10 +58,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}"`);
 }
@@ -94,14 +94,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
@@ -119,15 +119,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);
     }
   }
   /**
@@ -136,7 +136,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();
   }
   /**
@@ -146,16 +146,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.
@@ -177,9 +177,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);`
@@ -370,12 +374,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));
@@ -430,7 +434,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(
         `
@@ -439,7 +443,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
@@ -664,7 +668,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) {
@@ -694,19 +698,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;
@@ -727,23 +731,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;
@@ -763,7 +767,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]);
@@ -870,11 +874,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();
     }
@@ -897,29 +901,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) {
@@ -937,16 +946,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,
@@ -962,15 +971,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();
@@ -986,7 +995,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,
@@ -997,8 +1006,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;
@@ -1024,10 +1033,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;
@@ -1064,19 +1073,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();
     };
   }
   /**
@@ -1147,11 +1156,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,
@@ -1169,6 +1179,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;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {