@rotorsoft/act-pg 1.17.1 → 1.19.0

package/dist/index.js

@@ -311,13 +311,36 @@ var PostgresStore = class {
       );
       await client.query(
         `CREATE TABLE IF NOT EXISTS ${this._fqc} (
-          id int PRIMARY KEY DEFAULT 0,
+          key text PRIMARY KEY,
           at int NOT NULL DEFAULT -1,
-          CONSTRAINT ${this.config.table}_correlated_singleton CHECK (id = 0)
+          leased_by text,
+          leased_until timestamptz
         ) TABLESPACE pg_default;`
       );
+      await client.query(`
+        DO $$
+        BEGIN
+          IF EXISTS (
+            SELECT 1 FROM information_schema.columns
+             WHERE table_schema = '${this.config.schema}'
+               AND table_name = '${this.config.table}_correlated'
+               AND column_name = 'id'
+          ) THEN
+            ALTER TABLE ${this._fqc} ADD COLUMN IF NOT EXISTS key text;
+            ALTER TABLE ${this._fqc} ADD COLUMN IF NOT EXISTS leased_by text;
+            ALTER TABLE ${this._fqc} ADD COLUMN IF NOT EXISTS leased_until timestamptz;
+            UPDATE ${this._fqc} SET key = '' WHERE key IS NULL;
+            ALTER TABLE ${this._fqc}
+              DROP CONSTRAINT IF EXISTS ${this.config.table}_correlated_singleton;
+            ALTER TABLE ${this._fqc}
+              DROP CONSTRAINT IF EXISTS ${this.config.table}_correlated_pkey;
+            ALTER TABLE ${this._fqc} DROP COLUMN IF EXISTS id;
+            ALTER TABLE ${this._fqc} ALTER COLUMN key SET NOT NULL;
+            ALTER TABLE ${this._fqc} ADD PRIMARY KEY (key);
+          END IF;
+        END $$;`);
       await client.query(
-        `INSERT INTO ${this._fqc} (id) VALUES (0) ON CONFLICT (id) DO NOTHING;`
+        `INSERT INTO ${this._fqc} (key) VALUES ('') ON CONFLICT (key) DO NOTHING;`
       );
       await client.query(
         `ALTER TABLE ${this._fqs}
@@ -782,7 +805,7 @@ var PostgresStore = class {
    * @param streams - Streams to register with optional source.
    * @returns subscribed count and current max watermark.
    */
-  async subscribe(streams, correlated_at) {
+  async subscribe(streams, correlated_at, correlator) {
     const client = await this._client("subscribe");
     try {
       await client.query("BEGIN");
@@ -819,20 +842,61 @@ var PostgresStore = class {
           [JSON.stringify(streams)]
         );
       }
-      if (correlated_at !== void 0)
+      let correlating;
+      if (correlator) {
+        const { rowCount } = await client.query(
+          `INSERT INTO ${this._fqc} (key, at, leased_by, leased_until)
+           SELECT $1,
+                  GREATEST(COALESCE($2::int, -1),
+                           COALESCE((SELECT at FROM ${this._fqc} WHERE key = ''), -1)),
+                  $3,
+                  -- A non-positive millis releases outright rather than
+                  -- setting an expiry a hair in the future, which would still
+                  -- refuse a successor asking in the same instant.
+                  CASE WHEN $4::int > 0
+                       THEN now() + ($4::int * interval '1 millisecond')
+                       ELSE NULL END
+           ON CONFLICT (key) DO UPDATE
+              SET at = GREATEST(${this._fqc}.at, COALESCE($2::int, -1)),
+                  leased_by = CASE WHEN $4::int > 0 THEN EXCLUDED.leased_by END,
+                  leased_until = EXCLUDED.leased_until
+            WHERE ${this._fqc}.leased_until IS NULL
+               OR ${this._fqc}.leased_until < now()
+               OR ${this._fqc}.leased_by = EXCLUDED.leased_by`,
+          [
+            correlator.key,
+            correlated_at ?? null,
+            correlator.by,
+            correlator.millis
+          ]
+        );
+        correlating = (rowCount ?? 0) > 0;
+        if (!correlating && correlated_at !== void 0)
+          await client.query(
+            `UPDATE ${this._fqc} SET at = GREATEST(at, $1::int) WHERE key = $2`,
+            [correlated_at, correlator.key]
+          );
+        if (correlated_at !== void 0)
+          await client.query(
+            `UPDATE ${this._fqc} SET at = GREATEST(at, $1::int) WHERE key = ''`,
+            [correlated_at]
+          );
+      } else if (correlated_at !== void 0)
         await client.query(
-          `UPDATE ${this._fqc} SET at = GREATEST(at, $1::int) WHERE id = 0`,
+          `UPDATE ${this._fqc} SET at = GREATEST(at, $1::int) WHERE key = ''`,
           [correlated_at]
         );
       const { rows } = await client.query(
         `SELECT (SELECT COALESCE(MAX(at), -1) FROM ${this._fqs}) AS max,
-                (SELECT at FROM ${this._fqc} WHERE id = 0) AS correlated_at`
+                (SELECT at FROM ${this._fqc} WHERE key = $1) AS correlated_at`,
+        [correlator?.key ?? ""]
       );
       await client.query("COMMIT");
       return {
         subscribed,
         watermark: rows[0]?.max ?? -1,
-        correlated_at: Number(rows[0]?.correlated_at ?? -1)
+        correlated_at: Number(rows[0]?.correlated_at ?? -1),
+        ...correlating === void 0 ? {} : { correlating }
       };
     } catch (error) {
       await client.query("ROLLBACK").catch(() => {
@@ -1505,12 +1569,6 @@ var PostgresStore = class {
         this._fqt
       ]);
       const result = /* @__PURE__ */ new Map();
-      const retired = full.filter((t) => t.snapshot === void 0).map((t) => t.stream);
-      if (retired.length) {
-        await client.query(`DELETE FROM ${this._fqs} WHERE stream = ANY($1)`, [
-          retired
-        ]);
-      }
       for (const { stream, snapshot, meta } of full) {
         const { rowCount } = await client.query(
           `DELETE FROM ${this._fqt} WHERE stream = $1`,