@hotmeshio/hotmesh 0.0.18 → 0.0.20

package/build/services/durable/worker.js

@@ -3,47 +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");
-/*
-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);
-});
-*/
 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) {
@@ -61,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;
@@ -79,8 +45,40 @@ 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, search) {
+        if (search?.schema) {
+            const store = hotMeshClient.engine.store;
+            const schema = [];
+            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 = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.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) {
-        //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
@@ -91,6 +89,7 @@ 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;
     }
@@ -115,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,
@@ -163,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);
@@ -206,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
@@ -254,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,11 +1,29 @@
-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.
      */
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
-    static data(command: 'del' | 'get' | 'set' | 'incr' | 'mult', ...args: string[]): Promise<number | boolean | string>;
+    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,63 +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");
-/*
-`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);
-}
-*/
+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({
@@ -89,53 +61,96 @@ class WorkflowService {
         }
         return proxy;
     }
-    static async data(command, ...args) {
+    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');
-        try {
-            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
-            const search = new search_1.Search(workflowId, hotMeshClient);
-            if (command === 'get') {
-                return await search.get(args[0]);
-            }
-            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]));
+        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 if (command === 'mult') {
-                return await search.mult(args[0], Number(args[1]));
+            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 || 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;
         }
@@ -143,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;
@@ -202,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);
@@ -227,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);
                     });
@@ -247,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 };