@hotmeshio/hotmesh 0.16.6 → 0.17.1

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.16.6",
+    "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/compiler/deployer.js

@@ -442,14 +442,15 @@ class Deployer {
             if (graph.hooks) {
                 for (const topic in graph.hooks) {
                     hookRules[topic] = graph.hooks[topic];
-                    const activityId = graph.hooks[topic][0].to;
-                    const targetActivity = graph.activities[activityId];
-                    if (targetActivity) {
-                        if (!targetActivity.hook) {
-                            targetActivity.hook = {};
+                    //create back-reference to the hook topic for ALL target activities
+                    for (const rule of graph.hooks[topic]) {
+                        const targetActivity = graph.activities[rule.to];
+                        if (targetActivity) {
+                            if (!targetActivity.hook) {
+                                targetActivity.hook = {};
+                            }
+                            targetActivity.hook.topic = topic;
                         }
-                        //create back-reference to the hook topic
-                        targetActivity.hook.topic = topic;
                     }
                 }
             }

package/build/services/durable/client.js

@@ -165,12 +165,28 @@ class ClientService {
              * hours before the workflow starts).
              */
             signal: async (signalId, data, namespace, expire) => {
-                const topic = `${namespace ?? factory_1.APP_ID}.wfs.signal`;
-                return await (await this.getHotMeshClient(topic, namespace)).signal(topic, {
+                const ns = namespace ?? factory_1.APP_ID;
+                const payload = {
                     id: signalId,
                     data,
                     ...(expire ? { $expire: expire } : {}),
-                });
+                };
+                //send collator topic first (creates pending if no collator),
+                //then inline waiter topic (delivers and cleans up collator pending)
+                try {
+                    const signalTopic = `${ns}.wfs.signal`;
+                    await (await this.getHotMeshClient(signalTopic, namespace)).signal(signalTopic, payload);
+                }
+                catch {
+                    //no hook rule — ignore
+                }
+                try {
+                    const waitTopic = `${ns}.wfs.wait`;
+                    return await (await this.getHotMeshClient(waitTopic, namespace)).signal(waitTopic, payload);
+                }
+                catch {
+                    //no hook rule — ignore
+                }
             },
             /**
              * Spawns an a new, isolated execution cycle within the same job.

package/build/services/durable/handle.js

@@ -101,11 +101,25 @@ class WorkflowHandleService {
      * @param expire - Optional pending signal TTL (e.g., '1h', '30d'). Default '10m'.
      */
     async signal(signalId, data, expire) {
-        await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.signal`, {
+        const payload = {
             id: signalId,
             data,
             ...(expire ? { $expire: expire } : {}),
-        });
+        };
+        //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.signal`, payload);
+        }
+        catch {
+            //no hook rule — ignore
+        }
+        try {
+            await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.wait`, payload);
+        }
+        catch {
+            //no hook rule — ignore
+        }
     }
     /**
      * Returns the current workflow state. For a completed workflow this

package/build/services/durable/schemas/factory.d.ts

@@ -1,4 +1,4 @@
-declare const APP_VERSION = "13";
+declare const APP_VERSION = "14";
 declare const APP_ID = "durable";
 /**
  * returns a new durable workflow schema

package/build/services/durable/schemas/factory.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
-const APP_VERSION = '13';
+const APP_VERSION = '14';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
@@ -320,14 +320,22 @@ const getWorkflowYAML = (app, version) => {
               schema:
                 type: object
                 properties:
+                  signalId:
+                    type: string
+                    description: the signal identifier to wait for
                   index:
                     type: number
-                    description: the index of the first signal in the array
-                  signal:
-                    type: object
-                    properties:
-                      signal:
-                        type: string
+                    description: the replay index (COUNTER++)
+                  workflowDimension:
+                    type: string
+                    description: empty string or dimensional path (,0,0,1)
+                  duration:
+                    type: number
+                    description: optional timeout in seconds
+                  workflowId:
+                    type: string
+                  originJobId:
+                    type: string
           job:
             maps:
               response: '{$self.output.data.response}'
@@ -359,6 +367,47 @@ const getWorkflowYAML = (app, version) => {
               continueGeneration: '{cycle_hook.output.data.continueGeneration}'
               continueArgs: '{cycle_hook.output.data.continueArgs}'
 
+        waiter:
+          title: Waits for a matching signal or optional timeout (single condition)
+          type: hook
+          sleep: '{worker.output.data.duration}'
+          hook:
+            type: object
+            properties:
+              signalData:
+                type: object
+          output:
+            maps:
+              signalId: '{worker.output.data.signalId}'
+          job:
+            maps:
+              idempotentcy-marker[-]:
+                '@pipe':
+                  - '@pipe':
+                    - ['-wait', '{worker.output.data.workflowDimension}', '-', '{worker.output.data.index}', '-']
+                    - ['{@string.concat}']
+                  - '@pipe':
+                    - '@pipe':
+                      - ['{$self.hook.data.id}']
+                    - '@pipe':
+                      - [type, wait, data, '{$self.hook.data}', ac, '{$job.metadata.jc}', au, '{$self.output.metadata.au}']
+                      - ['{@object.create}']
+                    - '@pipe':
+                      - [timedOut, true, ac, '{$self.output.metadata.ac}', au, '{$self.output.metadata.au}']
+                      - ['{@object.create}']
+                    - ['{@conditional.ternary}']
+                  - ['{@object.create}']
+
+        wait_cycler:
+          title: Cycles back to the cycle_hook after signal wait
+          type: cycle
+          ancestor: cycle_hook
+          input:
+            maps:
+              retryCount: 0
+              continueGeneration: '{cycle_hook.output.data.continueGeneration}'
+              continueArgs: '{cycle_hook.output.data.continueArgs}'
+
         childer:
           title: Awaits a child flow to be executed/started
           type: await
@@ -1072,14 +1121,22 @@ const getWorkflowYAML = (app, version) => {
               schema:
                 type: object
                 properties:
+                  signalId:
+                    type: string
+                    description: the signal identifier to wait for
                   index:
                     type: number
-                    description: the index of the first signal in the array
-                  signal:
-                    type: object
-                    properties:
-                      signal:
-                        type: string
+                    description: the replay index (COUNTER++)
+                  workflowDimension:
+                    type: string
+                    description: empty string or dimensional path (,0,0,1)
+                  duration:
+                    type: number
+                    description: optional timeout in seconds
+                  workflowId:
+                    type: string
+                  originJobId:
+                    type: string
 
         signaler_sleeper:
           title: Pauses a single thread within the worker for a set amount of seconds while the main flow thread and all other subthreads remain active
@@ -1105,6 +1162,45 @@ const getWorkflowYAML = (app, version) => {
             maps:
               retryCount: 0
 
+        signaler_waiter:
+          title: Waits for a matching signal or optional timeout (single condition in signal-in path)
+          type: hook
+          sleep: '{signaler_worker.output.data.duration}'
+          hook:
+            type: object
+            properties:
+              signalData:
+                type: object
+          output:
+            maps:
+              signalId: '{signaler_worker.output.data.signalId}'
+          job:
+            maps:
+              idempotentcy-marker[-]:
+                '@pipe':
+                  - '@pipe':
+                    - ['-wait', '{signaler_worker.output.data.workflowDimension}', '-', '{signaler_worker.output.data.index}', '-']
+                    - ['{@string.concat}']
+                  - '@pipe':
+                    - '@pipe':
+                      - ['{$self.hook.data.id}']
+                    - '@pipe':
+                      - [type, wait, data, '{$self.hook.data}', ac, '{$job.metadata.jc}', au, '{$self.output.metadata.au}']
+                      - ['{@object.create}']
+                    - '@pipe':
+                      - [timedOut, true, ac, '{$self.output.metadata.ac}', au, '{$self.output.metadata.au}']
+                      - ['{@object.create}']
+                    - ['{@conditional.ternary}']
+                  - ['{@object.create}']
+
+        signaler_wait_cycler:
+          title: Cycles back to signaler_cycle_hook after signal wait
+          type: cycle
+          ancestor: signaler_cycle_hook
+          input:
+            maps:
+              retryCount: 0
+
         signaler_childer:
           title: Awaits a child flow to be executed/started
           type: await
@@ -1546,6 +1642,9 @@ const getWorkflowYAML = (app, version) => {
           - to: sleeper
             conditions:
               code: 588
+          - to: waiter
+            conditions:
+              code: 595
           - to: collator
             conditions:
               code: 589
@@ -1589,6 +1688,8 @@ const getWorkflowYAML = (app, version) => {
           - to: proxy_cycler
         sleeper:
           - to: sleep_cycler
+        waiter:
+          - to: wait_cycler
         ### SUBPROCESS TRANSITIONS (REENTRY) ###
         signaler:
           - to: signaler_cycle_hook
@@ -1600,6 +1701,9 @@ const getWorkflowYAML = (app, version) => {
           - to: signaler_sleeper
             conditions:
               code: 588
+          - to: signaler_waiter
+            conditions:
+              code: 595
           - to: signaler_collator
             conditions:
               code: 589
@@ -1627,6 +1731,8 @@ const getWorkflowYAML = (app, version) => {
           - to: signaler_proxy_cycler
         signaler_sleeper:
           - to: signaler_sleep_cycler
+        signaler_waiter:
+          - to: signaler_wait_cycler
 
       hooks:
         ${app}.flow.signal:
@@ -1635,7 +1741,17 @@ const getWorkflowYAML = (app, version) => {
               match:
                 - expected: '{trigger.output.data.workflowId}'
                   actual: '{$self.hook.data.id}'
-
+        ${app}.wfs.wait:
+          - to: waiter
+            conditions:
+              match:
+                - expected: '{worker.output.data.signalId}'
+                  actual: '{$self.hook.data.id}'
+          - to: signaler_waiter
+            conditions:
+              match:
+                - expected: '{signaler_worker.output.data.signalId}'
+                  actual: '{$self.hook.data.id}'
 
 
     ###################################################

package/build/services/durable/worker.js

@@ -799,10 +799,33 @@ class WorkerService {
                 if (isProcessing) {
                     return;
                 }
-                if (err instanceof errors_1.DurableWaitForError ||
-                    interruptionRegistry.length > 1) {
+                if (err instanceof errors_1.DurableWaitForError &&
+                    interruptionRegistry.length === 1) {
+                    //single condition() — handle inline, no collator needed
                     isProcessing = true;
-                    //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `condition`
+                    const workflowInput = data.data;
+                    const execIndex = counter.counter;
+                    const { workflowId, workflowDimension, originJobId } = workflowInput;
+                    return withPatchMarkers({
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: enums_1.HMSH_CODE_DURABLE_WAIT,
+                        metadata: { ...data.metadata },
+                        data: {
+                            code: enums_1.HMSH_CODE_DURABLE_WAIT,
+                            signalId: interruptionRegistry[0].signalId,
+                            index: execIndex,
+                            workflowDimension: interruptionRegistry[0].workflowDimension ||
+                                workflowDimension ||
+                                '',
+                            duration: interruptionRegistry[0].duration,
+                            workflowId,
+                            originJobId: originJobId || workflowId,
+                        },
+                    });
+                }
+                else if (interruptionRegistry.length > 1) {
+                    isProcessing = true;
+                    //NOTE: this type is spawned when `Promise.all` is used (multiple items to collate)
                     const workflowInput = data.data;
                     const execIndex = counter.counter - interruptionRegistry.length + 1;
                     const { workflowId, workflowTopic, workflowDimension, originJobId, expire, } = workflowInput;

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

@@ -70,11 +70,25 @@ async function signal(signalId, data, expire) {
         namespace,
     });
     if (await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'signal')) {
-        return await hotMeshClient.signal(`${namespace}.wfs.signal`, {
+        const payload = {
             id: signalId,
             data,
             ...(expire ? { $expire: expire } : {}),
-        });
+        };
+        //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.signal`, payload);
+        }
+        catch {
+            //no hook rule — ignore
+        }
+        try {
+            return await hotMeshClient.signal(`${namespace}.wfs.wait`, payload);
+        }
+        catch {
+            //no hook rule — ignore
+        }
     }
 }
 exports.signal = signal;

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

@@ -204,6 +204,13 @@ const KVTables = (context) => ({
                 expiry TIMESTAMP WITH TIME ZONE
               );
             `);
+                        if (tableDef.name === 'signal_registry') {
+                            await client.query(`
+                CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_expiry
+                  ON ${fullTableName} (expiry)
+                  WHERE expiry IS NOT NULL;
+              `);
+                        }
                         break;
                     case 'hash':
                         await client.query(`

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.16.6",
+  "version": "0.17.1",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",