@rotorsoft/act-pg 1.12.0 → 1.13.1

package/dist/index.js

@@ -413,16 +413,13 @@ var PostgresStore = class {
   async commit(stream, msgs, meta, expectedVersion) {
     if (msgs.length === 0) return [];
     const client = await this._client("commit");
-    let version = -1;
     try {
-      await client.query("BEGIN");
       const last = await client.query(
-        `SELECT version
-        FROM ${this._fqt}
-        WHERE stream=$1 ORDER BY version DESC LIMIT 1`,
+        `SELECT version FROM ${this._fqt}
+         WHERE stream=$1 ORDER BY version DESC LIMIT 1`,
         [stream]
       );
-      version = last.rowCount ? last.rows[0].version : -1;
+      let version = last.rows.at(0)?.version ?? -1;
       if (typeof expectedVersion === "number" && version !== expectedVersion)
         throw new ConcurrencyError(
           stream,
@@ -430,52 +427,69 @@ var PostgresStore = class {
           msgs,
           expectedVersion
         );
-      const committed = [];
+      const base_version = version;
+      const names = [];
+      const datas = [];
+      const piis = [];
+      const versions = [];
       for (const { name, data, pii } of msgs) {
         version++;
-        const sql = `
+        names.push(name);
+        datas.push(JSON.stringify(data));
+        piis.push(
+          this._resolve_pii_key && pii != null ? JSON.stringify(await encrypt(pii, this._resolve_pii_key)) : pii != null ? JSON.stringify(pii) : null
+        );
+        versions.push(version);
+      }
+      const insert_select = msgs.length === 1 ? `SELECT $1, $2::jsonb, $3::jsonb, $5, $4::int, $6 FROM l` : `SELECT u.name, u.data::jsonb, u.pii::jsonb, $5, u.version, $6
+             FROM l, unnest($1::text[], $2::text[], $3::text[], $4::int[])
+               WITH ORDINALITY AS u(name, data, pii, version, ord)
+             ORDER BY u.ord`;
+      const notify_ctes = this.config.notify ? `,
+           payload AS (
+             SELECT json_build_object(
+               'stream', $5::text,
+               'events', json_agg(json_build_object('id', ins.id, 'name', ins.name) ORDER BY ins.version),
+               'by', $9::text
+             )::text AS p
+             FROM ins
+           ),
+           n AS (
+             SELECT pg_notify($8, payload.p) FROM payload
+             WHERE octet_length(payload.p) < $10
+           )` : "";
+      const final_select = this.config.notify ? "SELECT ins.* FROM ins LEFT JOIN n ON true ORDER BY ins.version" : "SELECT * FROM ins ORDER BY version";
+      const sql = `WITH l AS (SELECT pg_advisory_xact_lock(hashtext($7))),
+        ins AS (
           INSERT INTO ${this._fqt}(name, data, pii, stream, version, meta)
-          VALUES($1, $2, $3, $4, $5, $6) RETURNING *`;
-        const pii_for_write = this._resolve_pii_key && pii != null ? JSON.stringify(await encrypt(pii, this._resolve_pii_key)) : pii ?? null;
-        const vals = [name, data, pii_for_write, stream, version, meta];
-        try {
-          const { rows } = await client.query(sql, vals);
-          const row = rows.at(0);
-          if (this._resolve_pii_key && typeof row.pii === "string") {
-            const decrypted = await decrypt(row.pii, this._resolve_pii_key);
-            row.pii = decrypted;
-          }
-          committed.push(row);
-        } catch (error) {
-          if (error?.code === PG_UNIQUE_VIOLATION) {
-            throw new ConcurrencyError(
-              stream,
-              version - 1,
-              msgs,
-              expectedVersion ?? -1
-            );
+          ${insert_select}
+          RETURNING *
+        )${notify_ctes}
+        ${final_select}`;
+      const base_params = msgs.length === 1 ? [names[0], datas[0], piis[0], versions[0], stream, meta, this._fqt] : [names, datas, piis, versions, stream, meta, this._fqt];
+      const params = this.config.notify ? [...base_params, this._channel, this._by, NOTIFY_MAX_PAYLOAD_BYTES] : base_params;
+      try {
+        const { rows } = await client.query(sql, params);
+        if (this._resolve_pii_key) {
+          for (const row of rows) {
+            if (typeof row.pii === "string") {
+              const decrypted = await decrypt(row.pii, this._resolve_pii_key);
+              row.pii = decrypted;
+            }
           }
-          throw error;
         }
+        return rows;
+      } catch (error) {
+        if (error?.code === PG_UNIQUE_VIOLATION) {
+          throw new ConcurrencyError(
+            stream,
+            base_version,
+            msgs,
+            expectedVersion ?? -1
+          );
+        }
+        throw error;
       }
-      if (this.config.notify) {
-        const payload = JSON.stringify({
-          stream,
-          events: committed.map((c) => ({ id: c.id, name: c.name })),
-          by: this._by
-        });
-        if (Buffer.byteLength(payload, "utf8") < NOTIFY_MAX_PAYLOAD_BYTES)
-          await client.query(`SELECT pg_notify($1, $2)`, [
-            this._channel,
-            payload
-          ]);
-      }
-      await client.query("COMMIT");
-      return committed;
-    } catch (error) {
-      await client.query("ROLLBACK").catch(() => {
-      });
-      throw error;
     } finally {
       client.release();
     }
@@ -1200,20 +1214,30 @@ var PostgresStore = class {
   }
   /**
    * Atomically truncates streams and seeds each with a snapshot or tombstone.
-   * @param targets - Streams to truncate with optional snapshot state and meta.
+   * Windowed targets (`before` set) prune the prefix below the closest safe
+   * `__snapshot__` instead — no seed, subscriptions untouched, no-op when no
+   * snapshot qualifies.
+   * @param targets - Streams to truncate with optional snapshot state and meta,
+   *   or a `before`/`max_id` boundary for a windowed prefix delete.
    * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.
    */
   async truncate(targets) {
     if (!targets.length) return /* @__PURE__ */ new Map();
-    const streams = targets.map((t) => t.stream);
+    const full = targets.filter((t) => t.before === void 0);
+    const windowed = targets.filter((t) => t.before !== void 0);
     const client = await this._client("truncate");
     try {
       await client.query("BEGIN");
-      await client.query(`DELETE FROM ${this._fqs} WHERE stream = ANY($1)`, [
-        streams
+      await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        this._fqt
       ]);
       const result = /* @__PURE__ */ new Map();
-      for (const { stream, snapshot, meta } of targets) {
+      if (full.length) {
+        await client.query(`DELETE FROM ${this._fqs} WHERE stream = ANY($1)`, [
+          full.map((t) => t.stream)
+        ]);
+      }
+      for (const { stream, snapshot, meta } of full) {
         const { rowCount } = await client.query(
           `DELETE FROM ${this._fqt} WHERE stream = $1`,
           [stream]
@@ -1234,6 +1258,27 @@ var PostgresStore = class {
           committed: rows[0]
         });
       }
+      for (const { stream, before, max_id } of windowed) {
+        const { rows } = await client.query(
+          `SELECT id, stream, version, name, data, created, meta
+           FROM ${this._fqt}
+           WHERE stream = $1 AND name = $2 AND created < $3
+             AND ($4::int IS NULL OR id <= $4)
+           ORDER BY id DESC LIMIT 1`,
+          [stream, SNAP_EVENT, before, max_id ?? null]
+        );
+        if (!rows.length) continue;
+        const boundary = rows[0];
+        const { rowCount } = await client.query(
+          `DELETE FROM ${this._fqt} WHERE stream = $1 AND id < $2`,
+          [stream, boundary.id]
+        );
+        result.set(stream, {
+          deleted: rowCount ?? 0,
+          committed: boundary,
+          before
+        });
+      }
       await client.query("COMMIT");
       return result;
     } catch (error) {