@hotmeshio/hotmesh 0.0.12 → 0.0.14

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

@@ -4,5 +4,6 @@ export declare class WorkflowHandleService {
     workflowTopic: string;
     workflowId: string;
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
+    signal(signalId: string, data: Record<any, any>): Promise<void>;
     result(): Promise<any>;
 }

package/build/services/durable/handle.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowHandleService = void 0;
+const factory_1 = require("./factory");
 class WorkflowHandleService {
     constructor(hotMesh, workflowTopic, workflowId) {
         this.workflowTopic = workflowTopic;
         this.workflowId = workflowId;
         this.hotMesh = hotMesh;
     }
+    async signal(signalId, data) {
+        await this.hotMesh.hook('durable.wfs.signal', { id: signalId, data });
+    }
     async result() {
         let status = await this.hotMesh.getStatus(this.workflowId);
-        const topic = `${this.workflowTopic}.${this.workflowId}`;
+        const topic = `${factory_1.PUBLISHES_TOPIC}.${this.workflowId}`;
         return new Promise((resolve, reject) => {
             let isResolved = false;
             //common fulfill/unsubscribe

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

@@ -7,12 +7,8 @@ export declare class WorkerService {
     workflowRunner: HotMesh;
     activityRunner: HotMesh;
     static getHotMesh: (worflowTopic: string, options?: WorkerOptions) => Promise<HotMesh>;
-    static activateWorkflow(hotMesh: HotMesh, topic: string, dagFactory: Function, options?: WorkerOptions): Promise<void>;
+    static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     /**
-     * The `worker` calls `registerActivities` immediately BEFORE
-     * dynamically importing the user's workflow module. That file
-     * contains a call, `proxyActivities`, which needs this info.
-     *
      * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
@@ -21,10 +17,9 @@ export declare class WorkerService {
     static create(config: WorkerConfig): Promise<WorkerService>;
     static resolveWorkflowTarget(workflow: object | Function): [string, Function];
     run(): Promise<void>;
-    initActivityWorkflow(config: WorkerConfig, activityTopic: string): Promise<HotMesh>;
+    initActivityWorker(config: WorkerConfig, activityTopic: string): Promise<HotMesh>;
     wrapActivityFunctions(): Function;
-    activateActivityWorkflow(hotMesh: HotMesh, activityTopic: string): Promise<void>;
-    initWorkerWorkflow(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh>;
+    initWorkflowWorker(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh>;
     static Context: {
         info: () => {
             workflowId: string;

package/build/services/durable/worker.js

@@ -2,34 +2,32 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
+const errors_1 = require("../../modules/errors");
 const asyncLocalStorage_1 = require("./asyncLocalStorage");
+const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
 const stream_1 = require("../../types/stream");
-const factory_1 = require("./factory");
-const errors_1 = require("../../modules/errors");
 /*
 Here is an example of how the methods in this file are used:
 
 ./worker.ts
 
-import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
+import { Durable } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
 import * as workflows from './workflows';
 
 async function run() {
-  const connection = await NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
+  const worker = await Durable.Worker.create({
+    connection: {
+      class: Redis,
+      options: {
+        host: 'localhost',
+        port: 6379,
+      },
     },
-  });
-  const worker = await Worker.create({
-    connection,
     taskQueue: 'hello-world',
     workflow: workflows.example,
-    activities,
   });
   await worker.run();
 }
@@ -40,14 +38,13 @@ run().catch((err) => {
 });
 */
 class WorkerService {
-    static async activateWorkflow(hotMesh, topic, dagFactory, options = {}) {
-        const version = '1';
-        const app = await hotMesh.engine.store.getApp(topic);
+    static async activateWorkflow(hotMesh) {
+        const app = await hotMesh.engine.store.getApp(factory_1.APP_ID);
         const appVersion = app?.version;
         if (!appVersion) {
             try {
-                await hotMesh.deploy(dagFactory(topic, version, options.maxSystemRetries, options.backoffExponent));
-                await hotMesh.activate(version);
+                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(factory_1.APP_ID, factory_1.APP_VERSION));
+                await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
                 hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
@@ -56,7 +53,7 @@ class WorkerService {
         }
         else if (app && !app.active) {
             try {
-                await hotMesh.activate(version);
+                await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
                 hotMesh.engine.logger.error('durable-worker-activate-err', err);
@@ -65,10 +62,6 @@ class WorkerService {
         }
     }
     /**
-     * The `worker` calls `registerActivities` immediately BEFORE
-     * dynamically importing the user's workflow module. That file
-     * contains a call, `proxyActivities`, which needs this info.
-     *
      * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
@@ -89,7 +82,6 @@ class WorkerService {
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
-        //user can provide the workflow file directly
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
@@ -97,10 +89,9 @@ class WorkerService {
         const workflowTopic = `${baseTopic}`;
         //initialize supporting workflows
         const worker = new WorkerService();
-        worker.activityRunner = await worker.initActivityWorkflow(config, activityTopic);
-        await WorkerService.activateWorkflow(worker.activityRunner, activityTopic, factory_1.getActivityYAML);
-        worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
-        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, factory_1.getWorkflowYAML, config.options);
+        worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
+        worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
+        await WorkerService.activateWorkflow(worker.workflowRunner);
         return worker;
     }
     static resolveWorkflowTarget(workflow) {
@@ -118,13 +109,13 @@ class WorkerService {
     async run() {
         this.workflowRunner.engine.logger.info('WorkerService is running');
     }
-    async initActivityWorkflow(config, activityTopic) {
+    async initActivityWorker(config, activityTopic) {
         const redisConfig = {
             class: config.connection.class,
             options: config.connection.options
         };
-        const hmshInstance = await hotmesh_1.HotMeshService.init({
-            appId: activityTopic,
+        const hotMeshWorker = await hotmesh_1.HotMeshService.init({
+            appId: factory_1.APP_ID,
             engine: { redis: redisConfig },
             workers: [
                 { topic: activityTopic,
@@ -133,8 +124,8 @@ class WorkerService {
                 }
             ]
         });
-        WorkerService.instances.set(activityTopic, hmshInstance);
-        return hmshInstance;
+        WorkerService.instances.set(activityTopic, hotMeshWorker);
+        return hotMeshWorker;
     }
     wrapActivityFunctions() {
         return async (data) => {
@@ -166,55 +157,30 @@ class WorkerService {
             }
         };
     }
-    async activateActivityWorkflow(hotMesh, activityTopic) {
-        const version = '1';
-        const app = await hotMesh.engine.store.getApp(activityTopic);
-        const appVersion = app?.version;
-        if (isNaN(appVersion)) {
-            try {
-                await hotMesh.deploy((0, factory_1.getActivityYAML)(activityTopic, version));
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('durable-worker-activity-deploy-activate-error', err);
-                throw err;
-            }
-        }
-        else if (app && !app.active) {
-            try {
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('durable-worker-activity-activate-err', err);
-                throw err;
-            }
-        }
-    }
-    async initWorkerWorkflow(config, workflowTopic, workflowFunction) {
+    async initWorkflowWorker(config, workflowTopic, workflowFunction) {
         const redisConfig = {
             class: config.connection.class,
             options: config.connection.options
         };
-        const hmshInstance = await hotmesh_1.HotMeshService.init({
-            appId: workflowTopic,
+        const hotMeshWorker = await hotmesh_1.HotMeshService.init({
+            appId: factory_1.APP_ID,
             engine: { redis: redisConfig },
-            workers: [
-                { topic: workflowTopic,
+            workers: [{
+                    topic: workflowTopic,
                     redis: redisConfig,
                     callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic).bind(this)
-                }
-            ]
+                }]
         });
-        WorkerService.instances.set(workflowTopic, hmshInstance);
-        return hmshInstance;
+        WorkerService.instances.set(workflowTopic, hotMeshWorker);
+        return hotMeshWorker;
     }
     wrapWorkflowFunction(workflowFunction, workflowTopic) {
         return async (data) => {
+            const counter = { counter: 0 };
             try {
                 //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
-                const counter = { counter: 0 };
                 context.set('counter', counter);
                 context.set('workflowId', workflowInput.workflowId);
                 context.set('workflowTopic', workflowTopic);
@@ -228,11 +194,47 @@ class WorkerService {
                     code: 200,
                     status: stream_1.StreamStatus.SUCCESS,
                     metadata: { ...data.metadata },
-                    data: { response: workflowResponse }
+                    data: { response: workflowResponse, done: true }
                 };
             }
             catch (err) {
-                // 59* - Durable*Error
+                //not an error...just a trigger to sleep
+                if (err instanceof errors_1.DurableSleepError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: err.code,
+                        metadata: { ...data.metadata },
+                        data: {
+                            code: err.code,
+                            message: JSON.stringify({ duration: err.duration, index: err.index }),
+                            duration: err.duration,
+                            index: err.index
+                        }
+                    };
+                    //not an error...just a trigger to wait for a signal
+                }
+                else if (err instanceof errors_1.DurableWaitForSignalError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: err.code,
+                        metadata: { ...data.metadata },
+                        data: {
+                            code: err.code,
+                            signals: err.signals,
+                            index: err.signals[0].index
+                        }
+                    };
+                    //not an error...still waiting for all the signals to arrive
+                }
+                else if (err instanceof errors_1.DurableIncompleteSignalError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: err.code,
+                        metadata: { ...data.metadata },
+                        data: { code: err.code }
+                    };
+                }
+                // all other errors are fatal (598, 597, 596) or will be retried (599)
                 return {
                     status: stream_1.StreamStatus.ERROR,
                     code: err.code || new errors_1.DurableRetryError(err.message).code,
@@ -256,13 +258,13 @@ WorkerService.getHotMesh = async (worflowTopic, options) => {
     if (WorkerService.instances.has(worflowTopic)) {
         return await WorkerService.instances.get(worflowTopic);
     }
-    const hotMesh = hotmesh_1.HotMeshService.init({
-        appId: worflowTopic,
+    const hotMeshClient = hotmesh_1.HotMeshService.init({
+        appId: factory_1.APP_ID,
         engine: { redis: { ...WorkerService.connection } }
     });
-    WorkerService.instances.set(worflowTopic, hotMesh);
-    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, factory_1.getWorkflowYAML, options);
-    return hotMesh;
+    WorkerService.instances.set(worflowTopic, hotMeshClient);
+    await WorkerService.activateWorkflow(await hotMeshClient);
+    return hotMeshClient;
 };
 WorkerService.Context = {
     info: () => {

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

@@ -1,6 +1,11 @@
 import { ActivityConfig, 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 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

@@ -9,25 +9,14 @@ 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");
 /*
 `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.
 
-`proxyActivities` must be called AFTER the activities
-have been registered in order to work properly.
-If the activities are not already registered,
-`proxyActivities` will throw an error. This is OK.
-
-The `client` (client.ts) is equivalent to the
-HotMesh `engine`. The jobs it creates will be
-put in the taskQueue. When the `worker` (worker.ts)
-is eventually initialized (if it happens to be inited later),
-it will see the items in the queue and process them. If it happens
-to already be inited, the jobs will immediately be dequeued and
-processed. In either case, the jobs will be processed.
-
 Here is an example of how the methods in this file are used:
 
 ./workflows.ts
@@ -51,6 +40,9 @@ export async function example(name: string): Promise<string> {
 }
 */
 class WorkflowService {
+    /**
+     * Spawn a child workflow. await the result.
+     */
     static async executeChild(options) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
         if (!store) {
@@ -62,7 +54,6 @@ class WorkflowService {
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
-        //todo: allow cross/app callback (pj:'@DURABLE@hello-world@<pjid>'/pa: <paid>/pd: <pdad>)
         const handle = await client.workflow.start({
             ...options,
             workflowId: `${workflowId}${options.workflowId}`,
@@ -86,6 +77,83 @@ class WorkflowService {
         }
         return proxy;
     }
+    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}`;
+        try {
+            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
+            await hotMeshClient.getState(factory_1.SLEEP_SUBSCRIBES_TOPIC, 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 errors_1.DurableSleepError(workflowId, seconds, execIndex);
+        }
+    }
+    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);
+        //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}`;
+            try {
+                if (allAreComplete) {
+                    const state = await hotMeshClient.getState(factory_1.WFS_SUBSCRIBES_TOPIC, wfsJobId);
+                    if (state.data?.signalData) {
+                        //user data is nested to isolate from the signal id; unpackage it
+                        const signalData = state.data.signalData;
+                        signalResults.push(signalData.data);
+                    }
+                    else {
+                        allAreComplete = false;
+                    }
+                }
+                else {
+                    signalResults.push({ signal, index: execIndex });
+                }
+            }
+            catch (err) {
+                //todo: options.startToCloseTimeout
+                allAreComplete = false;
+                noneAreComplete = true;
+                signalResults.push({ signal, index: execIndex });
+            }
+        }
+        ;
+        if (allAreComplete) {
+            return signalResults;
+        }
+        else if (noneAreComplete) {
+            //this error is caught by the workflow runner
+            //it is then returned as the workflow result (594)
+            throw new errors_1.DurableWaitForSignalError(workflowId, signalResults);
+        }
+        else {
+            //this error happens when a signal is received but others are still open
+            throw new errors_1.DurableIncompleteSignalError(workflowId);
+        }
+    }
     static wrapActivity(activityName, options) {
         return async function () {
             const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
@@ -103,21 +171,20 @@ class WorkflowService {
             const activityJobId = `${workflowId}-${activityName}-${execIndex}`;
             let activityState;
             try {
-                const hmshInstance = await worker_1.WorkerService.getHotMesh(activityTopic);
-                activityState = await hmshInstance.getState(activityTopic, activityJobId);
+                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic);
+                activityState = await hotMeshClient.getState(factory_1.ACTIVITY_SUBSCRIBES_TOPIC, activityJobId);
                 if (activityState.metadata.err) {
-                    await hmshInstance.scrub(activityJobId);
+                    await hotMeshClient.scrub(activityJobId);
                     throw new Error(activityState.metadata.err);
                 }
-                else if (activityState.metadata.js === 0) {
-                    //return immediately
+                else if (activityState.metadata.js === 0 || activityState.data?.done) {
                     return activityState.data?.response;
                 }
                 //one time subscription
                 return await new Promise((resolve, reject) => {
-                    hmshInstance.sub(activityTopic, async (topic, message) => {
+                    hotMeshClient.sub(`${factory_1.ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`, async (topic, message) => {
                         const response = message.data?.response;
-                        hmshInstance.unsub(activityTopic);
+                        hotMeshClient.unsub(`${factory_1.ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`);
                         // Resolve the Promise when the callback is triggered with a message
                         resolve(response);
                     });
@@ -128,14 +195,16 @@ class WorkflowService {
                 const duration = (0, ms_1.default)(options?.startToCloseTimeout || '1 minute');
                 const payload = {
                     arguments: Array.from(arguments),
+                    //the parent id is provided to categorize this activity for later cleanup
+                    parentWorkflowId: `${workflowId}-a`,
                     workflowId: activityJobId,
-                    workflowTopic,
+                    workflowTopic: activityTopic,
                     activityName,
                 };
                 //start the job
-                const hmshInstance = await worker_1.WorkerService.getHotMesh(activityTopic);
+                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic);
                 const context = { metadata: { trc, spn }, data: {} };
-                const jobOutput = await hmshInstance.pubsub(activityTopic, payload, context, duration);
+                const jobOutput = await hotMeshClient.pubsub(factory_1.ACTIVITY_SUBSCRIBES_TOPIC, payload, context, duration);
                 return jobOutput.data.response;
             }
         };

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

@@ -54,27 +54,27 @@ declare class EngineService {
     getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
     resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
     processStreamMessage(streamData: StreamDataResponse): Promise<void>;
-    execAdjacentParent(context: JobState, jobOutput: JobOutput): Promise<string>;
+    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<string>;
     hasParentJob(context: JobState): boolean;
     resolveError(metadata: JobMetadata): StreamError | undefined;
     scrub(jobId: string): Promise<void>;
-    hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void>;
+    hook(topic: string, data: JobData, dad?: string): Promise<string>;
     hookTime(jobId: string, activityId: string): Promise<JobStatus | void>;
-    hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
+    hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     pub(topic: string, data: JobData, context?: JobState): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
     unsub(topic: string): Promise<void>;
     psub(wild: string, callback: JobMessageCallback): Promise<void>;
     punsub(wild: string): Promise<void>;
     pubsub(topic: string, data: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
-    resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput): Promise<void>;
+    resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
     getPublishesTopic(context: JobState): Promise<string>;
-    resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput): Promise<void>;
+    resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
     add(streamData: StreamData | StreamDataResponse): Promise<string>;
     registerJobCallback(jobId: string, jobCallback: JobMessageCallback): void;
     delistJobCallback(jobId: string): void;
     hasOneTimeSubscription(context: JobState): boolean;
-    runJobCompletionTasks(context: JobState): Promise<void>;
+    runJobCompletionTasks(context: JobState, emit?: boolean): Promise<void>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;
     compress(terms: string[]): Promise<boolean>;

package/build/services/engine/index.js

@@ -23,6 +23,7 @@ const stream_2 = require("../../types/stream");
 //wait time to see if a job is complete
 const OTT_WAIT_TIME = 1000;
 const STATUS_CODE_SUCCESS = 200;
+const STATUS_CODE_PENDING = 202;
 const STATUS_CODE_TIMEOUT = 504;
 class EngineService {
     constructor() {
@@ -275,7 +276,7 @@ class EngineService {
         });
     }
     // ***************** `AWAIT` ACTIVITY RETURN RESPONSE ****************
-    async execAdjacentParent(context, jobOutput) {
+    async execAdjacentParent(context, jobOutput, emit = false) {
         if (this.hasParentJob(context)) {
             //errors are stringified `StreamError` objects
             const error = this.resolveError(jobOutput.metadata);
@@ -296,6 +297,10 @@ class EngineService {
                 streamData.data = error;
                 streamData.code = error.code;
             }
+            else if (emit) {
+                streamData.status = stream_2.StreamStatus.PENDING;
+                streamData.code = STATUS_CODE_PENDING;
+            }
             else {
                 streamData.status = stream_2.StreamStatus.SUCCESS;
                 streamData.code = STATUS_CODE_SUCCESS;
@@ -336,7 +341,7 @@ class EngineService {
             },
             data,
         };
-        await this.streamSignaler.publishMessage(null, streamData);
+        return await this.streamSignaler.publishMessage(null, streamData);
     }
     async hookTime(jobId, activityId) {
         //the activityid is concatenated with its dimensional address (dad); split to resolve
@@ -353,17 +358,19 @@ class EngineService {
         };
         await this.streamSignaler.publishMessage(null, streamData);
     }
-    async hookAll(hookTopic, data, query, queryFacets = []) {
+    async hookAll(hookTopic, data, keyResolver, queryFacets = []) {
         const config = await this.getVID();
         const hookRule = await this.storeSignaler.getHookRule(hookTopic);
         if (hookRule) {
             const subscriptionTopic = await (0, utils_1.getSubscriptionTopic)(hookRule.to, this.store, config);
-            const resolvedQuery = await this.resolveQuery(subscriptionTopic, query);
+            const resolvedQuery = await this.resolveQuery(subscriptionTopic, keyResolver);
             const reporter = new reporter_1.ReporterService(config, this.store, this.logger);
             const workItems = await reporter.getWorkItems(resolvedQuery, queryFacets);
-            const taskService = new task_1.TaskService(this.store, this.logger);
-            await taskService.enqueueWorkItems(workItems.map(workItem => `${hookTopic}::${workItem}::${JSON.stringify(data)}`));
-            this.store.publish(key_1.KeyType.QUORUM, { type: 'work', originator: this.guid }, this.appId);
+            if (workItems.length) {
+                const taskService = new task_1.TaskService(this.store, this.logger);
+                await taskService.enqueueWorkItems(workItems.map(workItem => `${hookTopic}::${workItem}::${keyResolver.scrub || false}::${JSON.stringify(data)}`));
+                this.store.publish(key_1.KeyType.QUORUM, { type: 'work', originator: this.guid }, this.appId);
+            }
             return workItems;
         }
         else {
@@ -436,7 +443,7 @@ class EngineService {
             }, timeout);
         });
     }
-    async resolveOneTimeSubscription(context, jobOutput) {
+    async resolveOneTimeSubscription(context, jobOutput, emit = false) {
         //todo: subscriber should query for the job...only publish minimum context needed
         if (this.hasOneTimeSubscription(context)) {
             const message = {
@@ -453,7 +460,7 @@ class EngineService {
         const schema = await this.store.getSchema(activityId, config);
         return schema.publishes;
     }
-    async resolvePersistentSubscriptions(context, jobOutput) {
+    async resolvePersistentSubscriptions(context, jobOutput, emit = false) {
         const topic = await this.getPublishesTopic(context);
         if (topic) {
             const message = {
@@ -476,20 +483,23 @@ class EngineService {
     hasOneTimeSubscription(context) {
         return Boolean(context.metadata.ngn);
     }
-    // ***************** JOB COMPLETION/CLEANUP *****************
-    async runJobCompletionTasks(context) {
+    // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
+    async runJobCompletionTasks(context, emit = false) {
+        //if 'emit' is true, the job isn't done. it's just emitting
         const isAwait = this.hasParentJob(context);
         const isOneTimeSubscription = this.hasOneTimeSubscription(context);
         const topic = await this.getPublishesTopic(context);
         if (isAwait || isOneTimeSubscription || topic) {
             const jobOutput = await this.getState(context.metadata.tpc, context.metadata.jid);
             //always wait for stream pub/sub
-            await this.execAdjacentParent(context, jobOutput);
+            await this.execAdjacentParent(context, jobOutput, emit);
             //no need to wait for standard pub/sub
-            this.resolveOneTimeSubscription(context, jobOutput);
-            this.resolvePersistentSubscriptions(context, jobOutput);
+            this.resolveOneTimeSubscription(context, jobOutput, emit);
+            this.resolvePersistentSubscriptions(context, jobOutput, emit);
+        }
+        if (!emit) {
+            this.task.registerJobForCleanup(context.metadata.jid, context.metadata.expire);
         }
-        this.task.registerJobForCleanup(context.metadata.jid, context.metadata.expire);
     }
     // ****** GET JOB STATE/COLLATION STATUS BY ID *********
     async getStatus(jobId) {