@hotmeshio/hotmesh 0.0.19 → 0.0.20

package/build/services/durable/worker.js

@@ -3,18 +3,18 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const errors_1 = require("../../modules/errors");
+const key_1 = require("../../modules/key");
 const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
 const stream_1 = require("../../types/stream");
-const key_1 = require("../../modules/key");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
-        const app = await hotMesh.engine.store.getApp(factory_1.APP_ID);
+        const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
         const appVersion = app?.version;
         if (!appVersion) {
             try {
-                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(factory_1.APP_ID, factory_1.APP_VERSION));
+                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(hotMesh.engine.appId, factory_1.APP_VERSION));
                 await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
@@ -32,11 +32,6 @@ class WorkerService {
             }
         }
     }
-    /**
-     * NOTE: Because the worker imports the workflows dynamically AFTER
-     * the activities are loaded, there will be items in the registry,
-     * allowing proxyActivities to succeed.
-     */
     static registerActivities(activities) {
         if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
             WorkerService.activityRegistry[activities.name] = activities;
@@ -52,10 +47,11 @@ class WorkerService {
     }
     /**
      * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow.
+     * this method will configure the search index for the workflow. For all
+     * others, this method will fail gracefully. In all cases, the values
+     * will be stored in the workflow's central HASH data structure, allowing
+     * for manual traversal and inspection as well.
      */
-    //todo: bind this to the Search service; update constructor to expect hotMeshClient as first param (id is optional
-    //refactor and delete other one as well)
     static async configureSearchIndex(hotMeshClient, search) {
         if (search?.schema) {
             const store = hotMeshClient.engine.store;
@@ -83,7 +79,6 @@ class WorkerService {
         }
     }
     static async create(config) {
-        //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
@@ -119,7 +114,8 @@ class WorkerService {
             options: config.connection.options
         };
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
-            appId: factory_1.APP_ID,
+            logLevel: config.options?.logLevel ?? 'info',
+            appId: config.namespace ?? factory_1.APP_ID,
             engine: { redis: redisConfig },
             workers: [
                 { topic: activityTopic,
@@ -167,26 +163,34 @@ class WorkerService {
             options: config.connection.options
         };
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
-            appId: factory_1.APP_ID,
+            logLevel: config.options?.logLevel ?? 'info',
+            appId: config.namespace ?? factory_1.APP_ID,
             engine: { redis: redisConfig },
             workers: [{
                     topic: workflowTopic,
                     redis: redisConfig,
-                    callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic).bind(this)
+                    callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic, config).bind(this)
                 }]
         });
         WorkerService.instances.set(workflowTopic, hotMeshWorker);
         return hotMeshWorker;
     }
-    wrapWorkflowFunction(workflowFunction, workflowTopic) {
+    wrapWorkflowFunction(workflowFunction, workflowTopic, config) {
         return async (data) => {
             const counter = { counter: 0 };
             try {
                 //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
+                context.set('namespace', config.namespace ?? factory_1.APP_ID);
                 context.set('counter', counter);
                 context.set('workflowId', workflowInput.workflowId);
+                if (data.data.workflowDimension) {
+                    //every hook function runs in an isolated dimension controlled
+                    //by the index assigned when the signal was received; even if the
+                    //hook function re-runs, its scope will always remain constant
+                    context.set('workflowDimension', data.data.workflowDimension);
+                }
                 context.set('workflowTopic', workflowTopic);
                 context.set('workflowName', workflowTopic.split('-').pop());
                 context.set('workflowTrace', data.metadata.trc);
@@ -210,9 +214,10 @@ class WorkerService {
                         metadata: { ...data.metadata },
                         data: {
                             code: err.code,
-                            message: JSON.stringify({ duration: err.duration, index: err.index }),
+                            message: JSON.stringify({ duration: err.duration, index: err.index, dimension: err.dimension }),
                             duration: err.duration,
-                            index: err.index
+                            index: err.index,
+                            dimension: err.dimension
                         }
                     };
                     //not an error...just a trigger to wait for a signal
@@ -258,15 +263,16 @@ class WorkerService {
 _a = WorkerService;
 WorkerService.activityRegistry = {}; //user's activities
 WorkerService.instances = new Map();
-WorkerService.getHotMesh = async (worflowTopic, options) => {
-    if (WorkerService.instances.has(worflowTopic)) {
-        return await WorkerService.instances.get(worflowTopic);
+WorkerService.getHotMesh = async (workflowTopic, config, options) => {
+    if (WorkerService.instances.has(workflowTopic)) {
+        return await WorkerService.instances.get(workflowTopic);
     }
     const hotMeshClient = hotmesh_1.HotMeshService.init({
-        appId: factory_1.APP_ID,
+        logLevel: options?.logLevel ?? 'info',
+        appId: config.namespace ?? factory_1.APP_ID,
         engine: { redis: { ...WorkerService.connection } }
     });
-    WorkerService.instances.set(worflowTopic, hotMeshClient);
+    WorkerService.instances.set(workflowTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
 };

package/build/services/durable/workflow.d.ts

@@ -1,5 +1,6 @@
-import { ActivityConfig, ProxyType, WorkflowOptions } from "../../types/durable";
 import { Search } from './search';
+import { HotMeshService as HotMesh } from '../hotmesh';
+import { ActivityConfig, HookOptions, ProxyType, WorkflowOptions } from "../../types/durable";
 export declare class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
@@ -7,6 +8,22 @@ export declare class WorkflowService {
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
     static search(): Promise<Search>;
+    /**
+     * those methods that may only be called once must be protected by flagging
+     * their execution with a unique key (the key is stored in the workflow state)
+     */
+    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
+    /**
+     * send signal data into any other paused thread (which is paused and
+     * awaiting the signal) from within a hook-thread or the main-thread
+     */
+    static signal(signalId: string, data: Record<any, any>): Promise<string>;
+    /**
+     * spawn a hook from either the main thread or a hook thread with
+     * the provided options; worflowId/TaskQueue/Name are optional and will
+     * default to the current workflowId/WorkflowTopic if not provided
+     */
+    static hook(options: HookOptions): Promise<string>;
     static sleep(duration: string): Promise<number>;
     static waitForSignal(signals: string[], options?: Record<string, string>): Promise<Record<any, any>[]>;
     static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;

package/build/services/durable/workflow.js

@@ -5,35 +5,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowService = void 0;
 const ms_1 = __importDefault(require("ms"));
+const errors_1 = require("../../modules/errors");
+const key_1 = require("../../modules/key");
 const asyncLocalStorage_1 = require("./asyncLocalStorage");
-const worker_1 = require("./worker");
 const client_1 = require("./client");
 const connection_1 = require("./connection");
 const factory_1 = require("./factory");
-const errors_1 = require("../../modules/errors");
 const search_1 = require("./search");
+const worker_1 = require("./worker");
+const stream_1 = require("../../types/stream");
 class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
      */
     static async executeChild(options) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-        if (!store) {
-            throw new Error('durable-store-not-found');
-        }
         const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTrace = store.get('workflowTrace');
         const workflowSpan = store.get('workflowSpan');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const childJobId = `${workflowId}-$${options.workflowName}-${execIndex}`;
+        const childJobId = `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
         const parentWorkflowId = `${workflowId}-f`;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
         let handle = await client.workflow.getHandle(options.taskQueue, options.workflowName, childJobId);
         try {
-            return await handle.result();
+            return await handle.result(true);
         }
         catch (error) {
             handle = await client.workflow.start({
@@ -63,28 +63,94 @@ class WorkflowService {
     }
     static async search() {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-        if (!store) {
-            throw new Error('durable-store-not-found');
-        }
         const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
-        return new search_1.Search(workflowId, hotMeshClient);
+        const namespace = store.get('namespace');
+        const COUNTER = store.get('counter');
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        //this ID is used as a item key with a hash (dash prefix ensures no collision)
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        const searchSessionId = `-search${workflowDimension}-${execIndex}`;
+        return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
+    }
+    /**
+     * those methods that may only be called once must be protected by flagging
+     * their execution with a unique key (the key is stored in the workflow state)
+     */
+    static async isSideEffectAllowed(hotMeshClient, prefix) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const COUNTER = store.get('counter');
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        //this ID is used as a item key with a hash (dash prefix ensures no collision)
+        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+        //this ID is used as a item key with a hash (dash prefix ensures no collision)
+        const keyParams = {
+            appId: hotMeshClient.appId,
+            jobId: ''
+        };
+        const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        const workflowGuid = `${hotMeshPrefix}${workflowId}`;
+        const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
+        return guidValue === 1;
+    }
+    /**
+     * send signal data into any other paused thread (which is paused and
+     * awaiting the signal) from within a hook-thread or the main-thread
+     */
+    static async signal(signalId, data) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const namespace = store.get('namespace');
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(`${namespace}.wfs.signal`, { namespace });
+        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
+            return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
+        }
+    }
+    /**
+     * spawn a hook from either the main thread or a hook thread with
+     * the provided options; worflowId/TaskQueue/Name are optional and will
+     * default to the current workflowId/WorkflowTopic if not provided
+     */
+    static async hook(options) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const namespace = store.get('namespace');
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
+        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
+            const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+            let workflowId;
+            let workflowTopic;
+            if (options.workflowId && options.taskQueue && options.workflowName) {
+                workflowId = options.workflowId;
+                workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+            }
+            else {
+                workflowId = store.get('workflowId');
+                workflowTopic = store.get('workflowTopic');
+            }
+            const payload = {
+                arguments: [...options.args],
+                id: workflowId,
+                workflowTopic,
+                backoffCoefficient: options.config?.backoffCoefficient || factory_1.DEFAULT_COEFFICIENT,
+            };
+            return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
+        }
     }
     static async sleep(duration) {
         const seconds = (0, ms_1.default)(duration) / 1000;
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-        if (!store) {
-            throw new Error('durable-store-not-found');
-        }
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const workflowId = store.get('workflowId');
         const workflowTopic = store.get('workflowTopic');
-        const sleepJobId = `${workflowId}-$sleep-${execIndex}`;
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const namespace = store.get('namespace');
+        const sleepJobId = `${workflowId}-$sleep${workflowDimension}-${execIndex}`;
         try {
-            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
-            await hotMeshClient.getState(factory_1.SLEEP_SUBSCRIBES_TOPIC, sleepJobId);
+            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+            await hotMeshClient.getState(`${hotMeshClient.appId}.sleep.execute`, sleepJobId);
             //if no error is thrown, we've already slept, return the delay
             return seconds;
         }
@@ -92,28 +158,27 @@ class WorkflowService {
             //if an error, the sleep job was not found...rethrow error; sleep job
             // will be automatically created according to the DAG rules (they
             // spawn a new sleep job if error code 595 is thrown by the worker)
-            throw new errors_1.DurableSleepError(workflowId, seconds, execIndex);
+            throw new errors_1.DurableSleepError(workflowId, seconds, execIndex, workflowDimension);
         }
     }
     static async waitForSignal(signals, options) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-        if (!store) {
-            throw new Error('durable-store-not-found');
-        }
         const COUNTER = store.get('counter');
         const workflowId = store.get('workflowId');
         const workflowTopic = store.get('workflowTopic');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const namespace = store.get('namespace');
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         //iterate the list of signals and check for done
         let allAreComplete = true;
         let noneAreComplete = false;
         const signalResults = [];
         for (const signal of signals) {
             const execIndex = COUNTER.counter = COUNTER.counter + 1;
-            const wfsJobId = `${workflowId}-$wfs-${execIndex}`;
+            const wfsJobId = `${workflowId}-$wfs${workflowDimension}-${execIndex}`;
             try {
                 if (allAreComplete) {
-                    const state = await hotMeshClient.getState(factory_1.WFS_SUBSCRIBES_TOPIC, wfsJobId);
+                    const state = await hotMeshClient.getState(`${hotMeshClient.appId}.wfs.execute`, wfsJobId);
                     if (state.data?.signalData) {
                         //user data is nested to isolate from the signal id; unpackage it
                         const signalData = state.data.signalData;
@@ -151,22 +216,21 @@ class WorkflowService {
     static wrapActivity(activityName, options) {
         return async function () {
             const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-            if (!store) {
-                throw new Error('durable-store-not-found');
-            }
             const COUNTER = store.get('counter');
             //increment by state (not value) to avoid race conditions
             const execIndex = COUNTER.counter = COUNTER.counter + 1;
             const workflowId = store.get('workflowId');
+            const workflowDimension = store.get('workflowDimension') ?? '';
             const workflowTopic = store.get('workflowTopic');
             const trc = store.get('workflowTrace');
             const spn = store.get('workflowSpan');
+            const namespace = store.get('namespace');
             const activityTopic = `${workflowTopic}-activity`;
-            const activityJobId = `${workflowId}-$${activityName}-${execIndex}`;
+            const activityJobId = `${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
             let activityState;
             try {
-                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic);
-                activityState = await hotMeshClient.getState(factory_1.ACTIVITY_SUBSCRIBES_TOPIC, activityJobId);
+                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic, { namespace });
+                activityState = await hotMeshClient.getState(`${hotMeshClient.appId}.activity.execute`, activityJobId);
                 if (activityState.metadata.err) {
                     await hotMeshClient.scrub(activityJobId);
                     throw new Error(activityState.metadata.err);
@@ -176,9 +240,9 @@ class WorkflowService {
                 }
                 //one time subscription
                 return await new Promise((resolve, reject) => {
-                    hotMeshClient.sub(`${factory_1.ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`, async (topic, message) => {
+                    hotMeshClient.sub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`, async (topic, message) => {
                         const response = message.data?.response;
-                        hotMeshClient.unsub(`${factory_1.ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`);
+                        hotMeshClient.unsub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`);
                         // Resolve the Promise when the callback is triggered with a message
                         resolve(response);
                     });
@@ -196,9 +260,9 @@ class WorkflowService {
                     activityName,
                 };
                 //start the job
-                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic);
+                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic, { namespace });
                 const context = { metadata: { trc, spn }, data: {} };
-                const jobOutput = await hotMeshClient.pubsub(factory_1.ACTIVITY_SUBSCRIBES_TOPIC, payload, context, duration);
+                const jobOutput = await hotMeshClient.pubsub(`${hotMeshClient.appId}.activity.execute`, payload, context, duration);
                 return jobOutput.data.response;
             }
         };

package/build/services/engine/index.d.ts

@@ -19,7 +19,7 @@ import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '..
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
-import { StreamData, StreamDataResponse, StreamError } from '../../types/stream';
+import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
 declare class EngineService {
     namespace: string;
     apps: HotMeshApps | null;
@@ -63,7 +63,7 @@ declare class EngineService {
     hasParentJob(context: JobState): boolean;
     resolveError(metadata: JobMetadata): StreamError | undefined;
     scrub(jobId: string): Promise<void>;
-    hook(topic: string, data: JobData, dad?: string): Promise<string>;
+    hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
     hookTime(jobId: string, activityId: string): Promise<JobStatus | void>;
     hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     pub(topic: string, data: JobData, context?: JobState): Promise<string>;

package/build/services/engine/index.js

@@ -248,7 +248,8 @@ class EngineService {
                 await activityHandler.process();
             }
             else {
-                await activityHandler.processWebHookEvent();
+                //a 202 code keeps the hook alive (hooks are single-use by default)
+                await activityHandler.processWebHookEvent(streamData.status, streamData.code);
             }
         }
         else if (streamData.type === stream_2.StreamDataType.AWAIT) {
@@ -269,7 +270,7 @@ class EngineService {
         }
         else {
             const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context);
-            await activityHandler.processEvent(streamData.status, streamData.code);
+            await activityHandler.processEvent(streamData.status, streamData.code, 'output');
         }
         this.logger.debug('engine-process-stream-message-end', {
             jid: streamData.metadata.jid,
@@ -323,21 +324,15 @@ class EngineService {
         await this.store.scrub(jobId);
     }
     // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
-    async hook(topic, data, dad) {
+    async hook(topic, data, status = stream_2.StreamStatus.SUCCESS, code = 200) {
         const hookRule = await this.storeSignaler.getHookRule(topic);
-        const [aid, schema] = await this.getSchema(`.${hookRule.to}`);
-        if (!dad) {
-            //assume dimensional address is singular (0)
-            // for ancestors and self if not provided
-            // todo: register
-            dad = ',0'.repeat(schema.ancestors.length + 1);
-        }
+        const [aid] = await this.getSchema(`.${hookRule.to}`);
         const streamData = {
             type: stream_2.StreamDataType.WEBHOOK,
+            status,
+            code,
             metadata: {
-                //jid is unknown at this point; will be resolved using the data
                 aid,
-                dad,
                 topic
             },
             data,

package/build/services/hotmesh/index.d.ts

@@ -6,7 +6,7 @@ import { JobState, JobData, JobOutput, JobStatus } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
-import { StreamData, StreamDataResponse } from '../../types/stream';
+import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 declare class HotMeshService {
     namespace: string;
     appId: string;
@@ -38,7 +38,7 @@ declare class HotMeshService {
     getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
     resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
     scrub(jobId: string): Promise<void>;
-    hook(topic: string, data: JobData, dad?: string): Promise<string>;
+    hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
     hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     stop(): Promise<void>;
     compress(terms: string[]): Promise<boolean>;

package/build/services/hotmesh/index.js

@@ -119,8 +119,8 @@ class HotMeshService {
         await this.engine?.scrub(jobId);
     }
     // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-    async hook(topic, data, dad) {
-        return await this.engine?.hook(topic, data, dad);
+    async hook(topic, data, status, code) {
+        return await this.engine?.hook(topic, data, status, code);
     }
     async hookAll(hookTopic, data, query, queryFacets = []) {
         return await this.engine?.hookAll(hookTopic, data, query, queryFacets);

package/build/services/signaler/store.d.ts

@@ -8,8 +8,8 @@ declare class StoreSignaler {
     logger: ILogger;
     constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
     getHookRule(topic: string): Promise<HookRule | undefined>;
-    registerWebHook(topic: string, context: JobState, multi?: RedisMulti): Promise<string>;
-    processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<string>;
+    registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string>;
+    processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string] | undefined>;
     deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number>;
 }
 export { StoreSignaler };

package/build/services/signaler/store.js

@@ -11,7 +11,7 @@ class StoreSignaler {
         const rules = await this.store.getHookRules();
         return rules?.[topic]?.[0];
     }
-    async registerWebHook(topic, context, multi) {
+    async registerWebHook(topic, context, dad, multi) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
             const mapExpression = hookRule.conditions.match[0].expected;
@@ -20,7 +20,8 @@ class StoreSignaler {
             const hook = {
                 topic,
                 resolved,
-                jobId,
+                //hookSignalId is composed of `<dad>::<jid>`
+                jobId: `${dad}::${jobId}`,
             };
             await this.store.setHookSignal(hook, multi);
             return jobId;
@@ -36,18 +37,27 @@ class StoreSignaler {
             const context = { $self: { hook: { data } }, $hook: { data } };
             const mapExpression = hookRule.conditions.match[0].actual;
             const resolved = pipe_1.Pipe.resolve(mapExpression, context);
-            const jobId = await this.store.getHookSignal(topic, resolved);
-            return jobId;
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return undefined
+                //users can also provide a bogus topic; not an issue; return undefined
+                return undefined;
+            }
+            const [dad, jid] = hookSignalId.split('::');
+            //return [jid, aid, dad]
+            return [jid, hookRule.to, dad];
         }
         else {
-            throw new Error('signaler.process:error: hook rule not found');
+            throw new Error('signal-not-found');
         }
     }
     async deleteWebHookSignal(topic, data) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
-            //todo: use the rule to generate `resolved`
-            const resolved = data.id;
+            //NOTE: both formats are supported: $self.hook.data OR $hook.data
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
             return await this.store.deleteHookSignal(topic, resolved);
         }
         else {

package/build/services/signaler/stream.js

@@ -121,6 +121,7 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (error) {
+            console.error(error);
             this.logger.error(`stream-call-function-error`, { error });
             output = this.structureUnhandledError(input, error);
         }

package/build/services/store/clients/redis.js

@@ -68,7 +68,7 @@ class RedisStoreService extends index_1.StoreService {
         }
         catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+            this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
             throw error;
         }
     }

package/build/services/store/index.js

@@ -422,6 +422,9 @@ class StoreService {
             }
             return [state, status];
         }
+        else {
+            throw new Error(`Job ${jobId} not found`);
+        }
     }
     async collate(jobId, activityId, amount, dIds, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });

package/build/services/telemetry/index.js

@@ -207,11 +207,17 @@ class TelemetryService {
     }
     static bindActivityTelemetryToState(state, config, metadata, context, leg) {
         if (config.type === 'trigger') {
+            //trigger activities run non-duplexed and only have a single leg (2)
             state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
             state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l2s;
         }
         else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' && leg === 1) {
-            //activities run non-duplexed and only have a single leg
+            //hook activities run non-duplexed and only have a single leg (1)
+            state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
+        }
+        else if (config.type === 'signal' && leg === 1) {
+            //signal activities run non-duplexed and only have a single leg (1)
             state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
             state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
         }

package/build/types/activity.d.ts

@@ -66,11 +66,13 @@ interface SignalActivity extends BaseActivity {
     type: 'signal';
     subtype: 'one' | 'all';
     topic: string;
-    key_name: string;
-    key_value: string;
-    scrub: boolean;
+    key_name?: string;
+    key_value?: string;
+    scrub?: boolean;
     signal?: Record<string, any>;
     resolver?: Record<string, any>;
+    status?: string;
+    code?: number;
 }
 interface IterateActivity extends BaseActivity {
     type: 'iterate';