@hotmeshio/hotmesh 0.0.12 → 0.0.14

package/services/durable/handle.ts

@@ -1,5 +1,6 @@
 import { JobOutput } from '../../types/job';
 import { HotMeshService as HotMesh } from '../hotmesh';
+import { PUBLISHES_TOPIC } from './factory';
 
 export class WorkflowHandleService {
   hotMesh: HotMesh;
@@ -12,9 +13,13 @@ export class WorkflowHandleService {
     this.hotMesh = hotMesh;
   }
 
+  async signal(signalId: string, data: Record<any, any>): Promise<void> {
+    await this.hotMesh.hook('durable.wfs.signal', { id: signalId, data });
+  }
+
   async result(): Promise<any> {
     let status = await this.hotMesh.getStatus(this.workflowId);
-    const topic = `${this.workflowTopic}.${this.workflowId}`;
+    const topic = `${PUBLISHES_TOPIC}.${this.workflowId}`;
   
     return new Promise((resolve, reject) => {
       let isResolved = false;

package/services/durable/worker.ts

@@ -1,43 +1,48 @@
+import {
+  DurableFatalError,
+  DurableIncompleteSignalError,
+  DurableMaxedError,
+  DurableRetryError,
+  DurableSleepError,
+  DurableTimeoutError, 
+  DurableWaitForSignalError} from '../../modules/errors';
 import { asyncLocalStorage } from './asyncLocalStorage';
+import { APP_ID, APP_VERSION, getWorkflowYAML } from './factory';
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { RedisClass, RedisOptions } from '../../types/redis';
-import { StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
-import { ActivityWorkflowDataType,
+import {
+  ActivityWorkflowDataType,
   Connection,
   Registry,
   WorkerConfig,
   WorkerOptions,
   WorkflowDataType } from "../../types/durable";
-import { getWorkflowYAML, getActivityYAML } from './factory';
+import { RedisClass, RedisOptions } from '../../types/redis';
 import {
-  DurableFatalError,
-  DurableMaxedError,
-  DurableRetryError,
-  DurableTimeoutError } from '../../modules/errors';
+  StreamData,
+  StreamDataResponse,
+  StreamStatus } from '../../types/stream';
 
 /*
 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();
 }
@@ -59,30 +64,29 @@ export class WorkerService {
     if (WorkerService.instances.has(worflowTopic)) {
       return await WorkerService.instances.get(worflowTopic);
     }
-    const hotMesh = HotMesh.init({
-      appId: worflowTopic,
+    const hotMeshClient = HotMesh.init({
+      appId: APP_ID,
       engine: { redis: { ...WorkerService.connection } }
     });
-    WorkerService.instances.set(worflowTopic, hotMesh);
-    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, getWorkflowYAML, options);
-    return hotMesh;
+    WorkerService.instances.set(worflowTopic, hotMeshClient);
+    await WorkerService.activateWorkflow(await hotMeshClient);
+    return hotMeshClient;
   }
 
-  static async activateWorkflow(hotMesh: HotMesh, topic: string, dagFactory: Function, options: WorkerOptions = {}) {
-    const version = '1';
-    const app = await hotMesh.engine.store.getApp(topic);
+  static async activateWorkflow(hotMesh: HotMesh) {
+    const app = await hotMesh.engine.store.getApp(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(getWorkflowYAML(APP_ID, APP_VERSION));
+        await hotMesh.activate(APP_VERSION);
       } catch (err) {
         hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
         throw err;
       }
     } else if(app && !app.active) {
       try {
-        await hotMesh.activate(version);
+        await hotMesh.activate(APP_VERSION);
       } catch (err) {
         hotMesh.engine.logger.error('durable-worker-activate-err', err);
         throw err;
@@ -91,10 +95,6 @@ export 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.
@@ -115,7 +115,6 @@ export class WorkerService {
   static async create(config: WorkerConfig) {
     //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}`;
@@ -124,10 +123,9 @@ export class WorkerService {
 
     //initialize supporting workflows
     const worker = new WorkerService();
-    worker.activityRunner = await worker.initActivityWorkflow(config, activityTopic);
-    await WorkerService.activateWorkflow(worker.activityRunner, activityTopic, getActivityYAML);
-    worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
-    await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, 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;
   }
 
@@ -147,13 +145,13 @@ export class WorkerService {
     this.workflowRunner.engine.logger.info('WorkerService is running');
   }
 
-  async initActivityWorkflow(config: WorkerConfig, activityTopic: string): Promise<HotMesh> {
+  async initActivityWorker(config: WorkerConfig, activityTopic: string): Promise<HotMesh> {
     const redisConfig = {
       class: config.connection.class as RedisClass,
       options: config.connection.options as RedisOptions
     };
-    const hmshInstance = await HotMesh.init({
-      appId: activityTopic,
+    const hotMeshWorker = await HotMesh.init({
+      appId: APP_ID,
       engine: { redis: redisConfig },
       workers: [
         { topic: activityTopic,
@@ -162,8 +160,8 @@ export class WorkerService {
         }
       ]
     });
-    WorkerService.instances.set(activityTopic, hmshInstance);
-    return hmshInstance;
+    WorkerService.instances.set(activityTopic, hotMeshWorker);
+    return hotMeshWorker;
   }
 
   wrapActivityFunctions(): Function {
@@ -197,45 +195,22 @@ export class WorkerService {
     }
   }
 
-  async activateActivityWorkflow(hotMesh: HotMesh, activityTopic: string) {
-    const version = '1';
-    const app = await hotMesh.engine.store.getApp(activityTopic);
-    const appVersion = app?.version as unknown as number;
-    if(isNaN(appVersion)) {
-      try {
-        await hotMesh.deploy(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: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh> {
+  async initWorkflowWorker(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh> {
     const redisConfig = {
       class: config.connection.class as RedisClass,
       options: config.connection.options as RedisOptions
     };
-    const hmshInstance = await HotMesh.init({
-      appId: workflowTopic,
+    const hotMeshWorker = await HotMesh.init({
+      appId: APP_ID,
       engine: { redis: redisConfig },
-      workers: [
-        { topic: workflowTopic,
-          redis: redisConfig,
-          callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic).bind(this)
-        }
-      ]
+      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;
   }
 
   static Context = {
@@ -249,11 +224,11 @@ export class WorkerService {
 
   wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string): 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();
-        const counter = { counter: 0 };
         context.set('counter', counter);
         context.set('workflowId', workflowInput.workflowId);
         context.set('workflowTopic', workflowTopic);
@@ -268,10 +243,48 @@ export class WorkerService {
           code: 200,
           status: 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 DurableSleepError) {
+          return {
+            status: 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
+            }
+          } as StreamDataResponse;
+
+        //not an error...just a trigger to wait for a signal
+        } else if (err instanceof DurableWaitForSignalError) {
+          return {
+            status: StreamStatus.SUCCESS,
+            code: err.code,
+            metadata: { ...data.metadata },
+            data: {
+              code: err.code,
+              signals: err.signals,
+              index: err.signals[0].index
+            }
+          } as StreamDataResponse;
+
+        //not an error...still waiting for all the signals to arrive
+        } else if (err instanceof DurableIncompleteSignalError) {
+          return {
+            status: StreamStatus.SUCCESS,
+            code: err.code,
+            metadata: { ...data.metadata },
+            data: { code: err.code }
+          } as StreamDataResponse;
+        }
+
+        // all other errors are fatal (598, 597, 596) or will be retried (599)
         return {
           status: StreamStatus.ERROR,
           code: err.code || new DurableRetryError(err.message).code,

package/services/durable/workflow.ts

@@ -6,6 +6,9 @@ import { ClientService as Client } from './client';
 import { ConnectionService as Connection } from './connection';
 import { ActivityConfig, ProxyType, WorkflowOptions } 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 { stringify } from 'querystring';
 
 /*
 `proxyActivities` returns a wrapped instance of the 
@@ -13,19 +16,6 @@ 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
@@ -50,6 +40,10 @@ export async function example(name: string): Promise<string> {
 */
 
 export class WorkflowService {
+
+  /**
+   * Spawn a child workflow. await the result.
+   */
   static async executeChild<T>(options: WorkflowOptions): Promise<T> {
     const store = asyncLocalStorage.getStore();
     if (!store) {
@@ -62,10 +56,9 @@ export class WorkflowService {
     const client = new Client({
       connection: await Connection.connect(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}`, //concat
+      workflowId: `${workflowId}${options.workflowId}`, //concat (caller MUST PROVIDE)
       workflowTrace,
       workflowSpan,
     });
@@ -89,6 +82,82 @@ export class WorkflowService {
     return proxy;
   }
 
+  static async sleep(duration: string): Promise<number> {
+    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}`;
+
+    try {
+      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
+      await hotMeshClient.getState(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 DurableSleepError(workflowId, seconds, execIndex);
+    }
+  }
+
+  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);
+
+    //iterate the list of signals and check for done
+    let allAreComplete = true;
+    let noneAreComplete = false;
+    const signalResults: any[] = [];
+    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(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 as { id: string, data: Record<any, any> };
+            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 DurableWaitForSignalError(workflowId, signalResults);
+    } else {
+      //this error happens when a signal is received but others are still open
+      throw new DurableIncompleteSignalError(workflowId);
+    }
+  }
+
   static wrapActivity<T>(activityName: string, options?: ActivityConfig): T {
     return async function() {
       const store = asyncLocalStorage.getStore();
@@ -107,20 +176,19 @@ export class WorkflowService {
 
       let activityState: JobOutput
       try {
-        const hmshInstance = await WorkerService.getHotMesh(activityTopic);
-        activityState = await hmshInstance.getState(activityTopic, activityJobId);
+        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
+        activityState = await hotMeshClient.getState(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 as T;
         }
         //one time subscription
         return await new Promise((resolve, reject) => {
-          hmshInstance.sub(activityTopic, async (topic, message) => {
+          hotMeshClient.sub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`, async (topic, message) => {
             const response = message.data?.response;
-            hmshInstance.unsub(activityTopic);
+            hotMeshClient.unsub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`);
             // Resolve the Promise when the callback is triggered with a message
             resolve(response);
           });
@@ -130,14 +198,16 @@ export class WorkflowService {
         const duration = ms(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 WorkerService.getHotMesh(activityTopic);
+        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
         const context = { metadata: { trc, spn }, data: {}};
-        const jobOutput = await hmshInstance.pubsub(activityTopic, payload, context as JobState, duration);
+        const jobOutput = await hotMeshClient.pubsub(ACTIVITY_SUBSCRIBES_TOPIC, payload, context as JobState, duration);
         return jobOutput.data.response as T;
       }
     } as T;

package/services/engine/index.ts

@@ -68,6 +68,7 @@ import { StringStringType } from '../../types';
 //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 {
@@ -366,7 +367,7 @@ class EngineService {
   }
 
   // ***************** `AWAIT` ACTIVITY RETURN RESPONSE ****************
-  async execAdjacentParent(context: JobState, jobOutput: JobOutput): Promise<string> {
+  async execAdjacentParent(context: JobState, jobOutput: JobOutput, emit = false): Promise<string> {
     if (this.hasParentJob(context)) {
       //errors are stringified `StreamError` objects
       const error = this.resolveError(jobOutput.metadata);
@@ -386,6 +387,9 @@ class EngineService {
         streamData.status = StreamStatus.ERROR;
         streamData.data = error;
         streamData.code = error.code;
+      } else if (emit) {
+        streamData.status = StreamStatus.PENDING;
+        streamData.code = STATUS_CODE_PENDING;
       } else {
         streamData.status = StreamStatus.SUCCESS;
         streamData.code = STATUS_CODE_SUCCESS;
@@ -409,7 +413,7 @@ class EngineService {
   }
 
   // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
-  async hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void> {
+  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
     const hookRule = await this.storeSignaler.getHookRule(topic);
     const [aid, schema] = await this.getSchema(`.${hookRule.to}`);
     if (!dad) {
@@ -428,7 +432,7 @@ class EngineService {
       },
       data,
     };
-    await this.streamSignaler.publishMessage(null, streamData);
+    return await this.streamSignaler.publishMessage(null, streamData) as string;
   }
   async hookTime(jobId: string, activityId: string): Promise<JobStatus | void> {
     //the activityid is concatenated with its dimensional address (dad); split to resolve
@@ -445,24 +449,26 @@ class EngineService {
     };
     await this.streamSignaler.publishMessage(null, streamData);
   }
-  async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
+  async hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
     const config = await this.getVID();
     const hookRule = await this.storeSignaler.getHookRule(hookTopic);
     if (hookRule) {
       const subscriptionTopic = await getSubscriptionTopic(hookRule.to, this.store, config)
-      const resolvedQuery = await this.resolveQuery(subscriptionTopic, query);
+      const resolvedQuery = await this.resolveQuery(subscriptionTopic, keyResolver);
       const reporter = new ReporterService(config, this.store, this.logger);
       const workItems = await reporter.getWorkItems(resolvedQuery, queryFacets);
-      const taskService = new TaskService(this.store, this.logger);
-      await taskService.enqueueWorkItems(
-        workItems.map(
-          workItem => `${hookTopic}::${workItem}::${JSON.stringify(data)}`
-      ));
-      this.store.publish(
-        KeyType.QUORUM,
-        { type: 'work', originator: this.guid },
-        this.appId
-      );
+      if (workItems.length) {
+        const taskService = new TaskService(this.store, this.logger);
+        await taskService.enqueueWorkItems(
+          workItems.map(
+            workItem => `${hookTopic}::${workItem}::${keyResolver.scrub || false}::${JSON.stringify(data)}`
+        ));
+        this.store.publish(
+          KeyType.QUORUM,
+          { type: 'work', originator: this.guid },
+          this.appId
+        );
+      }
       return workItems;
     } else {
       throw new Error(`unable to find hook rule for topic ${hookTopic}`);
@@ -472,7 +478,7 @@ class EngineService {
 
   // ********************** PUB/SUB ENTRY POINT **********************
   //publish (returns just the job id)
-  async pub(topic: string, data: JobData, context?: JobState) {
+  async pub(topic: string, data: JobData, context?: JobState): Promise<string> {
     const activityHandler = await this.initActivity(topic, data, context);
     if (activityHandler) {
       return await activityHandler.process();
@@ -534,7 +540,7 @@ class EngineService {
       }, timeout);
     });
   }
-  async resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput) {
+  async resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput, emit = false) {
     //todo: subscriber should query for the job...only publish minimum context needed
     if (this.hasOneTimeSubscription(context)) {
       const message: JobMessage = {
@@ -551,7 +557,7 @@ class EngineService {
     const schema = await this.store.getSchema(activityId, config);
     return schema.publishes;
   }
-  async resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput) {
+  async resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput, emit = false) {
     const topic = await this.getPublishesTopic(context);
     if (topic) {
       const message: JobMessage = {
@@ -577,20 +583,23 @@ class EngineService {
   }
 
 
-  // ***************** JOB COMPLETION/CLEANUP *****************
-  async runJobCompletionTasks(context: JobState) {
+  // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
+  async runJobCompletionTasks(context: JobState, 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);
   }
 
 

package/services/hotmesh/index.ts

@@ -63,6 +63,10 @@ class HotMeshService {
     return instance;
   }
 
+  static guid(): string {
+    return nanoid();
+  }
+
   async initEngine(config: HotMeshConfig, logger: ILogger): Promise<void> {
     if (config.engine) {
       await ConnectorService.initRedisClients(
@@ -104,7 +108,7 @@ class HotMeshService {
   }
 
   // ************* PUB/SUB METHODS *************
-  async pub(topic: string, data: JobData = {}, context?: JobState) {
+  async pub(topic: string, data: JobData = {}, context?: JobState): Promise<string> {
     return await this.engine?.pub(topic, data, context);
   }
   async sub(topic: string, callback: JobMessageCallback): Promise<void> {
@@ -145,7 +149,7 @@ class HotMeshService {
   async getStatus(jobId: string): Promise<JobStatus> {
     return this.engine?.getStatus(jobId);
   }
-  async getState(topic: string, jobId: string) {
+  async getState(topic: string, jobId: string): Promise<JobOutput> {
     return this.engine?.getState(topic, jobId);
   }
   async getIds(topic: string, query: JobStatsInput, queryFacets = []): Promise<IdsResponse> {
@@ -161,8 +165,7 @@ class HotMeshService {
   }
 
   // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-  async hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void> {
-    //return collation int
+  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
     return await this.engine?.hook(topic, data, dad);
   }
   async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {

package/services/mapper/index.ts

@@ -59,7 +59,7 @@ class MapperService {
     if (typeof transitionRule === 'boolean') {
       return transitionRule;
     }
-    if (code.toString() === (transitionRule.code || 200).toString()) {
+    if ((Array.isArray(transitionRule.code) && transitionRule.code.includes(code || 200)) || code.toString() === (transitionRule.code || 200).toString()) {
       if (!transitionRule.match) {
         return true;
       }