@hotmeshio/hotmesh 0.17.0 → 0.17.1

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.17.0",
+    "version": "0.17.1",
     "description": "Durable Workflow",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",

package/build/services/activities/hook.js

@@ -358,6 +358,23 @@ class Hook extends activity_1.Activity {
                     await this.processEvent(status, code, 'hook');
                     if (code === 200) {
                         await taskService.deleteWebHookSignal(this.config.hook.topic, data);
+                        //clean up orphan pending on the sibling signal topic
+                        //  wfs.wait delivered → remove wfs.signal pending
+                        //  wfs.signal delivered → remove wfs.wait pending
+                        const topic = this.config.hook.topic;
+                        const siblingTopic = topic.includes('.wfs.wait')
+                            ? topic.replace('.wfs.wait', '.wfs.signal')
+                            : topic.includes('.wfs.signal')
+                                ? topic.replace('.wfs.signal', '.wfs.wait')
+                                : null;
+                        if (siblingTopic) {
+                            try {
+                                await taskService.deleteWebHookSignal(siblingTopic, data);
+                            }
+                            catch {
+                                //sibling entry may not exist — ignore
+                            }
+                        }
                     }
                     return;
                 }

package/build/services/durable/client.js

@@ -171,21 +171,21 @@ class ClientService {
                     data,
                     ...(expire ? { $expire: expire } : {}),
                 };
-                //try inline waiter (v14+: single condition handled without collator)
+                //send collator topic first (creates pending if no collator),
+                //then inline waiter topic (delivers and cleans up collator pending)
                 try {
-                    const waitTopic = `${ns}.wfs.wait`;
-                    await (await this.getHotMeshClient(waitTopic, namespace)).signal(waitTopic, payload);
+                    const signalTopic = `${ns}.wfs.signal`;
+                    await (await this.getHotMeshClient(signalTopic, namespace)).signal(signalTopic, payload);
                 }
                 catch {
-                    //no hook rule for wfs.wait (pre-v14 or Promise.all) — ignore
+                    //no hook rule — ignore
                 }
-                //also signal collator path (Promise.all or pre-v14 single conditions)
                 try {
-                    const signalTopic = `${ns}.wfs.signal`;
-                    return await (await this.getHotMeshClient(signalTopic, namespace)).signal(signalTopic, payload);
+                    const waitTopic = `${ns}.wfs.wait`;
+                    return await (await this.getHotMeshClient(waitTopic, namespace)).signal(waitTopic, payload);
                 }
                 catch {
-                    //no hook rule for wfs.signal — ignore
+                    //no hook rule — ignore
                 }
             },
             /**

package/build/services/durable/handle.js

@@ -106,19 +106,19 @@ class WorkflowHandleService {
             data,
             ...(expire ? { $expire: expire } : {}),
         };
-        //try inline waiter (v14+: single condition handled without collator)
+        //send collator topic first (creates pending if no collator),
+        //then inline waiter topic (delivers and cleans up collator pending)
         try {
-            await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.wait`, payload);
+            await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.signal`, payload);
         }
         catch {
-            //no hook rule for wfs.wait (pre-v14 or Promise.all) — ignore
+            //no hook rule — ignore
         }
-        //also signal collator path (Promise.all or pre-v14 single conditions)
         try {
-            await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.signal`, payload);
+            await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.wait`, payload);
         }
         catch {
-            //no hook rule for wfs.signal — ignore
+            //no hook rule — ignore
         }
     }
     /**

package/build/services/durable/workflow/signal.js

@@ -75,19 +75,19 @@ async function signal(signalId, data, expire) {
             data,
             ...(expire ? { $expire: expire } : {}),
         };
-        //try inline waiter (v14+: single condition handled without collator)
+        //send collator topic first (creates pending if no collator),
+        //then inline waiter topic (delivers and cleans up collator pending)
         try {
-            await hotMeshClient.signal(`${namespace}.wfs.wait`, payload);
+            await hotMeshClient.signal(`${namespace}.wfs.signal`, payload);
         }
         catch {
-            //no hook rule for wfs.wait (pre-v14 or Promise.all) — ignore
+            //no hook rule — ignore
         }
-        //also signal collator path (Promise.all or pre-v14 single conditions)
         try {
-            return await hotMeshClient.signal(`${namespace}.wfs.signal`, payload);
+            return await hotMeshClient.signal(`${namespace}.wfs.wait`, payload);
         }
         catch {
-            //no hook rule for wfs.signal — ignore
+            //no hook rule — ignore
         }
     }
 }

package/build/services/store/providers/postgres/postgres.js

@@ -775,36 +775,46 @@ class PostgresStoreService extends __1.StoreService {
         const fullKey = `${key}:${signalKey}`;
         const delay = Math.max(hook.expire, enums_1.HMSH_SIGNAL_EXPIRE);
         if (transaction) {
-            await this.kvsql(transaction).setnxex(fullKey, jobId, delay);
+            //in-transaction: unconditional upsert (overwrites $pending)
+            const kv = this.kvsql();
+            const tableName = kv.tableForKey(fullKey);
+            const storedKey = kv.storageKey(fullKey);
+            transaction.addCommand(`INSERT INTO ${tableName} (key, value, expiry)
+         VALUES ($1, $2, NOW() + INTERVAL '${delay} seconds')
+         ON CONFLICT (key) DO UPDATE
+           SET value = EXCLUDED.value, expiry = EXCLUDED.expiry`, [storedKey, jobId], 'boolean');
             return { success: true };
         }
+        //standalone: atomic CTE — read prior value + upsert in one statement.
+        //eliminates the advisory lock TOCTOU race (reentrant on same session).
         const kv = this.kvsql();
         const tableName = kv.tableForKey(fullKey);
         const storedKey = kv.storageKey(fullKey);
-        //acquire per-key advisory lock (session-level) to serialize
-        //with concurrent getHookSignal for the same signal key
-        await this.pgClient.query('SELECT pg_advisory_lock(901, hashtext($1))', [storedKey]);
         try {
-            //read existing value under lock
-            const readRes = await this.pgClient.query(`SELECT value FROM ${tableName}
-         WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())`, [storedKey]);
-            let pendingData;
-            if (readRes.rows.length > 0) {
-                const existing = readRes.rows[0].value;
-                if (existing?.startsWith('$pending::')) {
-                    pendingData = existing.slice('$pending::'.length);
-                }
-                else {
-                    //hook already set (retry) — no change needed
-                    return { success: false };
-                }
+            const result = await this.pgClient.query(`WITH prior AS (
+          SELECT value FROM ${tableName}
+          WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+        )
+        INSERT INTO ${tableName} (key, value, expiry)
+        VALUES ($1, $2, NOW() + INTERVAL '${delay} seconds')
+        ON CONFLICT (key) DO UPDATE
+          SET value = EXCLUDED.value, expiry = EXCLUDED.expiry
+        RETURNING (SELECT value FROM prior) as prior_value`, [storedKey, jobId]);
+            const priorValue = result.rows[0]?.prior_value;
+            if (priorValue?.startsWith('$pending::')) {
+                this.logger.debug('hook-signal-pending-consumed', {
+                    key: signalKey,
+                });
+                return {
+                    success: true,
+                    pendingData: priorValue.slice('$pending::'.length),
+                };
             }
-            //insert hook value (or overwrite pending)
-            await this.pgClient.query(`INSERT INTO ${tableName} (key, value, expiry)
-         VALUES ($1, $2, NOW() + INTERVAL '${delay} seconds')
-         ON CONFLICT (key) DO UPDATE
-           SET value = EXCLUDED.value, expiry = EXCLUDED.expiry`, [storedKey, jobId]);
-            return { success: true, pendingData };
+            if (priorValue && !priorValue.startsWith('$pending::')) {
+                //hook already set by a previous Leg1 (idempotent)
+                return { success: false };
+            }
+            return { success: true };
         }
         catch (error) {
             if (error?.message?.includes('closed') ||
@@ -813,14 +823,6 @@ class PostgresStoreService extends __1.StoreService {
             }
             throw error;
         }
-        finally {
-            try {
-                await this.pgClient.query('SELECT pg_advisory_unlock(901, hashtext($1))', [storedKey]);
-            }
-            catch {
-                //lock auto-releases on session close
-            }
-        }
     }
     /**
      * Leg2: get hook signal OR atomically set a pending signal.
@@ -849,30 +851,40 @@ class PostgresStoreService extends __1.StoreService {
                 return undefined;
             return value;
         }
+        //atomic CTE: check for hook, store $pending if not found.
+        //eliminates the advisory lock TOCTOU race (reentrant on same session).
         const kv = this.kvsql();
         const tableName = kv.tableForKey(fullKey);
         const storedKey = kv.storageKey(fullKey);
         const expire = pendingExpire || enums_1.HMSH_PENDING_SIGNAL_EXPIRE;
         const pendingValue = `$pending::${pendingData}`;
-        //acquire per-key advisory lock (session-level) to serialize
-        //with concurrent setHookSignal for the same signal key
-        await this.pgClient.query('SELECT pg_advisory_lock(901, hashtext($1))', [storedKey]);
         try {
-            //read existing value under lock
-            const readRes = await this.pgClient.query(`SELECT value FROM ${tableName}
-         WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())`, [storedKey]);
-            if (readRes.rows.length > 0) {
-                const value = readRes.rows[0].value;
-                if (value && !value.startsWith('$pending::')) {
-                    //hook found — return it
-                    return value;
-                }
+            const result = await this.pgClient.query(`WITH prior AS (
+          SELECT value FROM ${tableName}
+          WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+        )
+        INSERT INTO ${tableName} (key, value, expiry)
+        VALUES ($1, $2, NOW() + INTERVAL '${expire} seconds')
+        ON CONFLICT (key) DO UPDATE
+          SET value = CASE
+            WHEN ${tableName}.value LIKE '$pending::%' THEN EXCLUDED.value
+            ELSE ${tableName}.value
+          END,
+          expiry = CASE
+            WHEN ${tableName}.value LIKE '$pending::%' THEN EXCLUDED.expiry
+            ELSE ${tableName}.expiry
+          END
+        RETURNING (SELECT value FROM prior) as prior_value`, [storedKey, pendingValue]);
+            const priorValue = result.rows[0]?.prior_value;
+            if (priorValue && !priorValue.startsWith('$pending::')) {
+                //hook found — return the composite job key
+                return priorValue;
             }
-            //no hook signal — store pending
-            await this.pgClient.query(`INSERT INTO ${tableName} (key, value, expiry)
-         VALUES ($1, $2, NOW() + INTERVAL '${expire} seconds')
-         ON CONFLICT (key) DO UPDATE
-           SET value = EXCLUDED.value, expiry = EXCLUDED.expiry`, [storedKey, pendingValue]);
+            //no hook — $pending was stored (or updated existing pending)
+            this.logger.debug('hook-signal-pending-stored', {
+                topic,
+                resolved,
+            });
             return undefined;
         }
         catch (error) {
@@ -882,14 +894,6 @@ class PostgresStoreService extends __1.StoreService {
             }
             throw error;
         }
-        finally {
-            try {
-                await this.pgClient.query('SELECT pg_advisory_unlock(901, hashtext($1))', [storedKey]);
-            }
-            catch {
-                //lock auto-releases on session close
-            }
-        }
     }
     async deleteHookSignal(topic, resolved) {
         const key = this.mintKey(key_1.KeyType.SIGNALS, { appId: this.appId });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",