@hotmeshio/hotmesh 0.0.18 → 0.0.20

package/services/durable/worker.ts

@@ -6,6 +6,7 @@ import {
   DurableSleepError,
   DurableTimeoutError, 
   DurableWaitForSignalError} from '../../modules/errors';
+import { KeyService, KeyType } from '../../modules/key';
 import { asyncLocalStorage } from './asyncLocalStorage';
 import { APP_ID, APP_VERSION, getWorkflowYAML } from './factory';
 import { HotMeshService as HotMesh } from '../hotmesh';
@@ -15,44 +16,14 @@ import {
   Registry,
   WorkerConfig,
   WorkerOptions,
-  WorkflowDataType } from "../../types/durable";
+  WorkflowDataType, 
+  WorkflowSearchOptions} from '../../types/durable';
 import { RedisClass, RedisOptions } from '../../types/redis';
 import {
   StreamData,
   StreamDataResponse,
   StreamStatus } from '../../types/stream';
 
-/*
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const worker = await Durable.Worker.create({
-    connection: {
-      class: Redis,
-      options: {
-        host: 'localhost',
-        port: 6379,
-      },
-    },
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-*/
-
 export class WorkerService {
   static activityRegistry: Registry = {}; //user's activities
   static connection: Connection;
@@ -60,25 +31,26 @@ export class WorkerService {
   workflowRunner: HotMesh;
   activityRunner: HotMesh;
 
-  static getHotMesh = async (worflowTopic: string, options?: WorkerOptions) => {
-    if (WorkerService.instances.has(worflowTopic)) {
-      return await WorkerService.instances.get(worflowTopic);
+  static getHotMesh = async (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => {
+    if (WorkerService.instances.has(workflowTopic)) {
+      return await WorkerService.instances.get(workflowTopic);
     }
     const hotMeshClient = HotMesh.init({
-      appId: APP_ID,
+      logLevel: options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? APP_ID,
       engine: { redis: { ...WorkerService.connection } }
     });
-    WorkerService.instances.set(worflowTopic, hotMeshClient);
+    WorkerService.instances.set(workflowTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
   }
 
   static async activateWorkflow(hotMesh: HotMesh) {
-    const app = await hotMesh.engine.store.getApp(APP_ID);
+    const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
     const appVersion = app?.version;
     if(!appVersion) {
       try {
-        await hotMesh.deploy(getWorkflowYAML(APP_ID, APP_VERSION));
+        await hotMesh.deploy(getWorkflowYAML(hotMesh.engine.appId, APP_VERSION));
         await hotMesh.activate(APP_VERSION);
       } catch (err) {
         hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
@@ -94,11 +66,6 @@ export 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<ACT>(activities: ACT): Registry  {
     if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
       WorkerService.activityRegistry[activities.name] = activities as Function;
@@ -112,8 +79,40 @@ export class WorkerService {
     return WorkerService.activityRegistry;
   }
 
+  /**
+   * For those deployments with a redis stack backend (with the FT module),
+   * 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.
+   */
+  static async configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void> {
+    if (search?.schema) {
+      const store = hotMeshClient.engine.store;
+      const schema: string[] = [];
+      for (const [key, value] of Object.entries(search.schema)) {
+        //prefix with a comma (avoids collisions with hotmesh reserved words)
+        schema.push(`_${key}`);
+        schema.push(value.type);
+        if (value.sortable) {
+          schema.push('SORTABLE');
+        }
+      }
+      try {
+        const keyParams = {
+          appId: hotMeshClient.appId,
+          jobId: ''
+        }
+        const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
+        const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
+        await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
+      } catch (err) {
+        hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+      }
+    }
+  }
+
   static async create(config: WorkerConfig) {
-    //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
     const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
@@ -125,6 +124,7 @@ export class WorkerService {
     const worker = new WorkerService();
     worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
     worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
+    WorkerService.configureSearchIndex(worker.workflowRunner, config.search)
     await WorkerService.activateWorkflow(worker.workflowRunner);
     return worker;
   }
@@ -151,7 +151,8 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      appId: APP_ID,
+      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? APP_ID,
       engine: { redis: redisConfig },
       workers: [
         { topic: activityTopic,
@@ -201,12 +202,13 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      appId: APP_ID,
+      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? 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);
@@ -222,15 +224,22 @@ export class WorkerService {
     },
   };
 
-  wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string): Function {
+  wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string, config: WorkerConfig): Function {
     return async (data: StreamData): Promise<StreamDataResponse> => {
      const counter = { counter: 0 };
       try {
         //incoming data payload has arguments and workflowId
         const workflowInput = data.data as unknown as WorkflowDataType;
         const context = new Map();
+        context.set('namespace', config.namespace ?? 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);
@@ -255,9 +264,10 @@ export 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
             }
           } as StreamDataResponse;
 

package/services/durable/workflow.ts

@@ -1,43 +1,24 @@
 import ms from 'ms';
 
+import {
+  DurableIncompleteSignalError,
+  DurableSleepError,
+  DurableWaitForSignalError } from '../../modules/errors';
+import { KeyService, KeyType } from '../../modules/key';
 import { asyncLocalStorage } from './asyncLocalStorage';
-import { WorkerService } from './worker';
 import { ClientService as Client } from './client';
 import { ConnectionService as Connection } from './connection';
-import { ActivityConfig, ProxyType, WorkflowConfig, WorkflowOptions, WorkflowSearchOptions } from "../../types/durable";
-import { JobOutput, JobState } from '../../types';
-import { ACTIVITY_PUBLISHES_TOPIC, ACTIVITY_SUBSCRIBES_TOPIC, SLEEP_SUBSCRIBES_TOPIC, WFS_SUBSCRIBES_TOPIC } from './factory';
-import { DurableIncompleteSignalError, DurableSleepError, DurableWaitForSignalError } from '../../modules/errors';
+import { DEFAULT_COEFFICIENT } from './factory';
 import { Search } from './search';
-
-/*
-`proxyActivities` returns a wrapped instance of the 
-target activity, so that when the workflow calls a
-proxied activity, it is actually calling the proxy
-function, which in turn calls the activity function.
-
-Here is an example of how the methods in this file are used:
-
-./workflows.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { greet } = Durable.workflow.proxyActivities<typeof activities>({
-  activities: activities,
-  startToCloseTimeout: '1 minute',
-  retryPolicy: {
-    initialInterval: '5 seconds',  // Initial delay between retries
-    maximumAttempts: 3,            // Max number of retry attempts
-    backoffCoefficient: 2.0,       // Backoff factor for delay between retries: delay = initialInterval * (backoffCoefficient ^ retry_attempt)
-    maximumInterval: '30 seconds', // Max delay between retries
-  },
-});
-
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-*/
+import { WorkerService } from './worker';
+import { HotMeshService as HotMesh } from '../hotmesh';
+import {
+  ActivityConfig,
+  HookOptions,
+  ProxyType,
+  WorkflowOptions } from "../../types/durable";
+import { JobOutput, JobState } from '../../types/job';
+import { StreamStatus } from '../../types/stream';
 
 export class WorkflowService {
 
@@ -46,15 +27,13 @@ export class WorkflowService {
    */
   static async executeChild<T>(options: WorkflowOptions): Promise<T> {
     const store = 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({
@@ -68,7 +47,7 @@ export class WorkflowService {
     );
 
     try {
-      return await handle.result() as T;
+      return await handle.result(true) as T;
     } catch (error) {
       handle = await client.workflow.start({
         ...options,
@@ -98,33 +77,83 @@ export class WorkflowService {
     return proxy;
   }
 
-  static async data(command: 'del' | 'get' | 'set' | 'incr' | 'mult', ...args: string[]): Promise<number | boolean | string> {
+  static async search(): Promise<Search> {
     const store = 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 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 WorkerService.getHotMesh(workflowTopic, { namespace });
+    const searchSessionId = `-search${workflowDimension}-${execIndex}`;
+    return new Search(workflowId, hotMeshClient, searchSessionId);
+  }
 
-    try {
-      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
-      const search = new Search(workflowId, hotMeshClient);
-      if (command === 'get') {
-        return await search.get(args[0]) as string;
-      } else if (command === 'set') {
-        await search.set(args[0], args[1]);
-        return true;
-      } else if (command === 'del') {
-        await search.del(args[0]);
-        return true;
-      } else if (command === 'incr') {
-        return await search.incr(args[0], Number(args[1])) as number;
-      } else if (command === 'mult') {
-        return await search.mult(args[0], Number(args[1])) as number;
+  /**
+   * 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: HotMesh, prefix:string): Promise<boolean> {
+    const store = 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 = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
+    const workflowGuid = `${hotMeshPrefix}${workflowId}`;
+    const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1') as string);
+    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: string, data: Record<any, any>): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const hotMeshClient = await 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: HookOptions): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
+    if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
+      const store = asyncLocalStorage.getStore();
+      let workflowId: string;
+      let workflowTopic: string;
+      if (options.workflowId && options.taskQueue && options.workflowName) {
+        workflowId = options.workflowId;
+        workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+      } else {
+        workflowId = store.get('workflowId');
+        workflowTopic = store.get('workflowTopic');
       }
-    } catch (e) {
-      console.error(e);
-      return '';
+      const payload = {
+        arguments: [...options.args],
+        id: workflowId,
+        workflowTopic,
+        backoffCoefficient: options.config?.backoffCoefficient || DEFAULT_COEFFICIENT,
+      }
+      return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, StreamStatus.PENDING, 202);
     }
   }
 
@@ -132,37 +161,35 @@ export class WorkflowService {
     const seconds = ms(duration) / 1000;
 
     const store = 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 WorkerService.getHotMesh(workflowTopic);
-      await hotMeshClient.getState(SLEEP_SUBSCRIBES_TOPIC, sleepJobId);
+      const hotMeshClient = await 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;
     } catch (e) {
       //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 DurableSleepError(workflowId, seconds, execIndex);
+      throw new DurableSleepError(workflowId, seconds, execIndex, workflowDimension);
     }
   }
 
   static async waitForSignal(signals: string[], options?: Record<string, string>): Promise<Record<any, any>[]> {
     const store = 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 WorkerService.getHotMesh(workflowTopic);
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const namespace = store.get('namespace');
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
 
     //iterate the list of signals and check for done
     let allAreComplete = true;
@@ -170,10 +197,10 @@ export class WorkflowService {
     const signalResults: any[] = [];
     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(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 as { id: string, data: Record<any, any> };
@@ -207,23 +234,22 @@ export class WorkflowService {
   static wrapActivity<T>(activityName: string, options?: ActivityConfig): T {
     return async function() {
       const store = 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: JobOutput
       try {
-        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
-        activityState = await hotMeshClient.getState(ACTIVITY_SUBSCRIBES_TOPIC, activityJobId);
+        const hotMeshClient = await 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);
@@ -232,9 +258,9 @@ export class WorkflowService {
         }
         //one time subscription
         return await new Promise((resolve, reject) => {
-          hotMeshClient.sub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`, async (topic, message) => {
+          hotMeshClient.sub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`, async (topic, message) => {
             const response = message.data?.response;
-            hotMeshClient.unsub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`);
+            hotMeshClient.unsub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`);
             // Resolve the Promise when the callback is triggered with a message
             resolve(response);
           });
@@ -251,9 +277,9 @@ export class WorkflowService {
           activityName,
         };
         //start the job
-        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
+        const hotMeshClient = await WorkerService.getHotMesh(activityTopic, { namespace });
         const context = { metadata: { trc, spn }, data: {}};
-        const jobOutput = await hotMeshClient.pubsub(ACTIVITY_SUBSCRIBES_TOPIC, payload, context as JobState, duration);
+        const jobOutput = await hotMeshClient.pubsub(`${hotMeshClient.appId}.activity.execute`, payload, context as JobState, duration);
         return jobOutput.data.response as T;
       }
     } as T;

package/services/engine/index.ts

@@ -60,6 +60,7 @@ import {
   StatsResponse
 } from '../../types/stats';
 import {
+  StreamCode,
   StreamData,
   StreamDataResponse,
   StreamDataType,
@@ -344,7 +345,8 @@ class EngineService {
       } else if (streamData.type === StreamDataType.TRANSITION) {
         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 === StreamDataType.AWAIT) {
       context.metadata = {
@@ -362,7 +364,7 @@ class EngineService {
       await activityHandler.processEvent(streamData.status, streamData.code);
     } else {
       const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context as JobState) as Worker;
-      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,
@@ -417,21 +419,15 @@ class EngineService {
   }
 
   // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
-  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
+  async hook(topic: string, data: JobData, status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<string> {
     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: StreamData = {
       type: StreamDataType.WEBHOOK,
+      status,
+      code,
       metadata: {
-        //jid is unknown at this point; will be resolved using the data
         aid,
-        dad,
         topic
       },
       data,

package/services/hotmesh/index.ts

@@ -20,7 +20,7 @@ import {
   IdsResponse,
   StatsResponse } from '../../types/stats';
 import { ConnectorService } from '../connector';
-import { StreamData, StreamDataResponse } from '../../types/stream';
+import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 
 class HotMeshService {
   namespace: string;
@@ -165,8 +165,8 @@ class HotMeshService {
   }
 
   // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
-    return await this.engine?.hook(topic, data, dad);
+  async hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string> {
+    return await this.engine?.hook(topic, data, status, code);
   }
   async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
     return await this.engine?.hookAll(hookTopic, data, query, queryFacets);

package/services/signaler/store.ts

@@ -19,7 +19,7 @@ class StoreSignaler {
     return rules?.[topic]?.[0] as HookRule;
   }
 
-  async registerWebHook(topic: string, context: JobState, multi?: RedisMulti): Promise<string> {
+  async registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
       const mapExpression = hookRule.conditions.match[0].expected;
@@ -28,7 +28,8 @@ class StoreSignaler {
       const hook: HookSignal = {
         topic,
         resolved,
-        jobId,
+        //hookSignalId is composed of `<dad>::<jid>`
+        jobId: `${dad}::${jobId}`,
       }
       await this.store.setHookSignal(hook, multi);
       return jobId;
@@ -37,25 +38,34 @@ class StoreSignaler {
     }
   }
 
-  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<string> {
+  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string] | undefined> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
       //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.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: string, data: Record<string, unknown>): Promise<number> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
-      //todo: use the rule to generate `resolved`
-      const resolved = (data as { id: string}).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.resolve(mapExpression, context);
       return await this.store.deleteHookSignal(topic, resolved);
     } else {
       throw new Error('signaler.process:error: hook rule not found');

package/services/signaler/stream.ts

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

package/services/store/clients/redis.ts

@@ -86,7 +86,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
     } 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;
     }
   }