@hotmeshio/hotmesh 0.0.9 → 0.0.11

package/README.md

@@ -1,7 +1,7 @@
 # HotMesh
 ![alpha release](https://img.shields.io/badge/release-alpha-yellow)
 
-Elevate Redis from an in-memory data store to a game-changing **service mesh**, delivering *durable* workflows without the overhead of a dedicated control plane. With HotMesh, you can keep your code at the forefront, utilizing [Redis infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already trust and own.
+Elevate Redis from an in-memory data store to a game-changing [service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh). Turn your unpredictable functions into unbreakable workflows.
 
 ## Install
 [![npm version](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh.svg)](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh)
@@ -11,85 +11,92 @@ npm install @hotmeshio/hotmesh
 ```
 
 ## Design
-HotMesh's TypeScript SDK is modeled after Temporal IO's developer-friendly approach. Design and deploy durable workflows using your preferred coding style. Write your functions as you normally would, then use the HotMesh to make them durable. Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond importing the HotMesh SDK.
+The HotMesh SDK is designed to keep your code front-and-center. Write functions as you normally would, then use HotMesh to make them durable.
 
->Start by defining activities. These are the functions that will be invoked by your workflow. They can be written in any style, using any framework, and can even be legacy functions you've already written. The only requirement is that they return a Promise.
+1. Start by defining **activities**. Activities are those functions that will be invoked by your workflow. They are commonly used to read and write to databases and invoke external services. They can be written in any style, using any framework, and can even be legacy functions you've already written. The only requirement is that they return a Promise. *Note how the `saludar` example throws an error 50% of the time. It doesn't matter how unpredictable your functions are, HotMesh will retry as necessary until they succeed.*
+    ```javascript
+    //activities.ts
 
-**./activities.ts**
-```javascript
-export async function greet(name: string): Promise<string> {
-  return `Hello, ${name}!`;
-}
-```
-
->Next, define your workflow. Include conditional logic, loops, etc. It's vanilla code written in your own coding style--just make sure to call `proxyActivities` to run your activities durably.
-
-**./workflows.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { greet } = Durable.workflow
-  .proxyActivities<typeof activities>({
-    activities
-  });
-
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-```
-
->Finally, create a worker and client. The *client* triggers workflows, while the *worker* runs them, retrying as necessary until the workflow succeeds--all without the need for complicated retry logic.
-
-**./client.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-import { v4 as uuidv4 } from 'uuid';
-
-async function run() {
-  const connection = await Durable.Connection.connect({
-    class: Redis,
-    options: { host: 'localhost', port: 6379 }
-  });
-
-  const client = new Durable.Client({
-    connection
-  });
-
-  const handle = await client.workflow.start({
-    args: ['HotMesh'],
-    taskQueue: 'hello-world',
-    workflowName: 'example',
-    workflowId: 'workflow-' + uuidv4()
-  });
-
-  console.log(await handle.result());
-}
-```
+    export async function greet(name: string): Promise<string> {
+      return `Hello, ${name}!`;
+    }
 
-**./worker.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
-import * as workflows from './workflows';
-
-async function run() {
-  const connection = await Durable.NativeConnection.connect({
-    class: Redis,
-    options: { host: 'localhost', port: 6379 },
-  });
-  const worker = await Durable.Worker.create({
-    connection,
-    namespace: 'default',
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-  });
-  await worker.run();
-}
-```
+    export async function saludar(nombre: string): Promise<string> {
+      Math.random() > 0.5 && throw new Error('Random error');
+      return `¡Hola, ${nombre}!`;
+    }
+    ```
+2. Define your **workflow** logic. Include conditional branching, loops, etc to control activity execution. It's vanilla code written in your own coding style. The only requirement is to use `proxyActivities`, ensuring your activities are executed with HotMesh's durability guarantee.
+    ```javascript
+    //workflows.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import * as activities from './activities';
+
+    const { greet, saludar } = Durable.workflow
+      .proxyActivities<typeof activities>({
+        activities
+      });
+
+    export async function example(name: string, lang: string): Promise<string> {
+      if (lang === 'es') {
+        return await saludar(name);
+      } else {
+        return await greet(name);
+      }
+    }
+    ```
+
+3. Although you could call your workflow directly (it's just a vanilla function), it's only durable when invoked and orchestrated via HotMesh. By using a HotMesh **client** to send the request, the function is guaranteed to return a result.
+    ```javascript
+    //client.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
+    import { v4 as uuidv4 } from 'uuid';
+
+    async function run(): Promise<string> {
+      const client = new Durable.Client({
+        connection: {
+          class: Redis,
+          options: { host: 'localhost', port: 6379 }
+        }
+      });
+
+      const handle = await client.workflow.start({
+        args: ['HotMesh', 'es'],
+        taskQueue: 'hello-world',
+        workflowName: 'example',
+        workflowId: uuidv4()
+      });
+
+      return await handle.result();
+      //returns '¡Hola, HotMesh!'
+    }
+    ```
+
+4. The last step is to create a **worker** and link it to your workflow function. Workers listen for tasks on their assigned channel, executing the linked workflow function until it succeeds.
+    ```javascript
+    //worker.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import Redis from 'ioredis';
+    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();
+    }
+    ```
 
->HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design delivers durable workflows without the cost and complexity of a centralized service mesh/control plane. Refer to the [hotmeshio/samples-typescript](https://github.com/hotmeshio/samples-typescript) Git Repo for a range of examples, including nested workflows.
+>HotMesh delivers durable workflows without the cost and complexity of a centralized service mesh. Refer to the [samples-typescript](https://github.com/hotmeshio/samples-typescript) Git Repo for a range of examples, including compositional workflows (where one workflow calls another) and remote execution (where calls are brokered across microservices).
 
 ## Advanced Design
 HotMesh's TypeScript SDK is the easiest way to make your functions durable. But if you need full control over your function lifecycles (including high-volume, high-speed use cases), you can use HotMesh's underlying YAML models to optimize your durable workflows. The following model depicts a sequence of activities orchestrated by HotMesh. Any function you associate with a `topic` in your YAML definition is guaranteed to be durable.
@@ -226,7 +233,7 @@ For a deep dive into HotMesh's distributed orchestration philosophy, refer to th
 HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchestration Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md) for a detailed breakdown of the approach.
 
 ## System Lifecycle
-Gain insight into the HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md).
+Gain insight into HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md).
 
 ## Alpha Release
 So what exacty is an [alpha release](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/alpha.md)?!

package/build/modules/errors.d.ts

@@ -6,6 +6,22 @@ declare class GetStateError extends Error {
 declare class SetStateError extends Error {
     constructor();
 }
+declare class DurableTimeoutError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableMaxedError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableFatalError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableRetryError extends Error {
+    code: number;
+    constructor(message: string);
+}
 declare class MapDataError extends Error {
     constructor();
 }
@@ -25,4 +41,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };
+export { CollationError, DurableTimeoutError, DurableMaxedError, DurableFatalError, DurableRetryError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/modules/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.CollationError = void 0;
+exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.DurableRetryError = exports.DurableFatalError = exports.DurableMaxedError = exports.DurableTimeoutError = exports.CollationError = void 0;
 class GetStateError extends Error {
     constructor() {
         super("Error occurred while getting job state");
@@ -13,6 +13,34 @@ class SetStateError extends Error {
     }
 }
 exports.SetStateError = SetStateError;
+class DurableTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 596;
+    }
+}
+exports.DurableTimeoutError = DurableTimeoutError;
+class DurableMaxedError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 597;
+    }
+}
+exports.DurableMaxedError = DurableMaxedError;
+class DurableFatalError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 598;
+    }
+}
+exports.DurableFatalError = DurableFatalError;
+class DurableRetryError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 599;
+    }
+}
+exports.DurableRetryError = DurableRetryError;
 class MapDataError extends Error {
     constructor() {
         super("Error occurred while mapping data");

package/build/modules/key.d.ts

@@ -25,7 +25,7 @@
  * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
-declare const PSNS = "hmsh";
+declare const HMNS = "hmsh";
 declare enum KeyType {
     APP = 0,
     ENGINE_ID = 1,
@@ -72,4 +72,4 @@ declare class KeyService {
      */
     static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
 }
-export { KeyService, KeyType, KeyStoreParams, PSNS };
+export { KeyService, KeyType, KeyStoreParams, HMNS };

package/build/modules/key.js

@@ -27,10 +27,10 @@
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PSNS = exports.KeyType = exports.KeyService = void 0;
+exports.HMNS = exports.KeyType = exports.KeyService = void 0;
 //default namespace for hotmesh
-const PSNS = "hmsh";
-exports.PSNS = PSNS;
+const HMNS = "hmsh";
+exports.HMNS = HMNS;
 //these are the entity types that are stored in the key/value store
 var KeyType;
 (function (KeyType) {

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.9",
+    "version": "0.0.11",
     "description": "Durable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -43,6 +43,7 @@
         "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
     },

package/build/services/activities/activity.d.ts

@@ -40,6 +40,7 @@ declare class Activity {
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;
     mapInputData(): void;
+    mapOutputData(): void;
     registerTimeout(): Promise<void>;
     bindActivityError(data: Record<string, unknown>): void;
     getTriggerConfig(): Promise<ActivityType>;

package/build/services/activities/activity.js

@@ -4,7 +4,6 @@ exports.Activity = void 0;
 const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const collator_1 = require("../collator");
-const dimension_1 = require("../dimension");
 const mapper_1 = require("../mapper");
 const pipe_1 = require("../pipe");
 const serializer_1 = require("../serializer");
@@ -43,6 +42,7 @@ class Activity {
             if (this.doesHook()) {
                 //sleep and wait to awaken upon a signal
                 await this.registerHook(multi);
+                this.mapOutputData();
                 this.mapJobData();
                 await this.setState(multi);
                 await collator_1.CollatorService.authorizeReentry(this, multi);
@@ -53,6 +53,7 @@ class Activity {
             else {
                 //end the activity and transition to its children
                 this.adjacencyList = await this.filterAdjacent();
+                this.mapOutputData();
                 this.mapJobData();
                 await this.setState(multi);
                 await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
@@ -265,6 +266,16 @@ class Activity {
             this.context.data = mapper.mapRules();
         }
     }
+    mapOutputData() {
+        //activity YAML may include output map data that produces/extends activity output data.
+        if (this.config.output?.maps) {
+            const mapper = new mapper_1.MapperService(this.config.output.maps, this.context);
+            const actOutData = mapper.mapRules();
+            const activityId = this.metadata.aid;
+            const data = { ...this.context[activityId].output, ...actOutData };
+            this.context[activityId].output.data = data;
+        }
+    }
     async registerTimeout() {
         //set timeout in support of hook and/or duplex
     }
@@ -442,7 +453,7 @@ class Activity {
     }
     resolveAdjacentDad() {
         //concat self and child dimension (all children (leg 1) begin life at 0)
-        return `${this.resolveDad()}${dimension_1.DimensionService.getSeed(0)}`;
+        return `${this.resolveDad()}${collator_1.CollatorService.getDimensionalSeed(0)}`;
     }
     ;
     async filterAdjacent() {

package/build/services/activities/cycle.js

@@ -63,13 +63,18 @@ class Cycle extends activity_1.Activity {
      * pattern allows for retries without violating the DAG.
      */
     async cycleAncestorActivity(multi) {
+        //Cycle activity L1 is a standin for the target ancestor L1.
+        //Input data mapping (mapInputData) allows for the 
+        //next dimensonal thread to execute with different
+        //input data than the current dimensional thread
+        this.mapInputData();
         const streamData = {
             metadata: {
                 dad: collator_1.CollatorService.resolveReentryDimension(this),
                 jid: this.context.metadata.jid,
                 aid: this.config.ancestor,
             },
-            data: {} //todo: verify immutability, before enabling: `this.context.data`
+            data: this.context.data
         };
         return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi));
     }

package/build/services/activities/trigger.js

@@ -6,7 +6,6 @@ const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const activity_1 = require("./activity");
 const collator_1 = require("../collator");
-const dimension_1 = require("../dimension");
 const pipe_1 = require("../pipe");
 const reporter_1 = require("../reporter");
 const serializer_1 = require("../serializer");
@@ -80,7 +79,7 @@ class Trigger extends activity_1.Activity {
         const jobKey = this.resolveJobKey(inputContext);
         const utc = (0, utils_1.formatISODate)(new Date());
         const { id, version } = await this.engine.getVID();
-        this.initDimensionalAddress(dimension_1.DimensionService.getSeed());
+        this.initDimensionalAddress(collator_1.CollatorService.getDimensionalSeed());
         const activityMetadata = {
             ...this.metadata,
             jid: jobId,
@@ -100,7 +99,7 @@ class Trigger extends activity_1.Activity {
                 trc: this.context.metadata.trc,
                 spn: this.context.metadata.spn,
                 jid: jobId,
-                dad: dimension_1.DimensionService.getSeed(),
+                dad: collator_1.CollatorService.getDimensionalSeed(),
                 key: jobKey,
                 jc: utc,
                 ju: utc,

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

@@ -69,5 +69,13 @@ declare class CollatorService {
      */
     static bindAncestorArray(graphs: HotMeshGraph[]): void;
     static isActivityComplete(status: number): boolean;
+    /**
+     * All activities exist on a dimensional plane. Zero
+     * is the default. A value of
+     * `AxY,0,0,0,0,1,0,0` would reflect that
+     * an ancestor activity was dimensionalized beyond
+     * the default.
+     */
+    static getDimensionalSeed(index?: number): string;
 }
 export { CollatorService };

package/build/services/collator/index.js

@@ -75,7 +75,7 @@ class CollatorService {
     static async notarizeCompletion(activity, multi) {
         //1) ALWAYS actualize leg2 dimension (+1)
         //2) IF the activity is used in a cycle, don't close leg 2!
-        const decrement = activity.config.cycle ? 0 : -1000000000000;
+        const decrement = activity.config.cycle ? 0 : 1000000000000;
         return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), multi);
     }
     ;
@@ -218,6 +218,16 @@ class CollatorService {
     static isActivityComplete(status) {
         return (status - 0) <= 0;
     }
+    /**
+     * All activities exist on a dimensional plane. Zero
+     * is the default. A value of
+     * `AxY,0,0,0,0,1,0,0` would reflect that
+     * an ancestor activity was dimensionalized beyond
+     * the default.
+     */
+    static getDimensionalSeed(index = 0) {
+        return `,${index}`;
+    }
 }
 exports.CollatorService = CollatorService;
 //max int digit count that supports `hincrby`

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

@@ -1,3 +1,20 @@
-declare const getWorkflowYAML: (topic: string, version?: string) => string;
+/**
+ * 1) `maxSystemRetries` | can be 0 to 3 and represents milliseconds;
+ * if there is an error, the workflow will retry up to `maxSystemRetries` times
+ * delaying by 10, 100, and 1000ms; this is a system level retry
+ * and is not configurable. It exists to handle intermittent network
+ * errors. (NOTE: each retry spawns a new transition stream)
+ *
+ * 2) `backoffExponent` | can be any number and represents `seconds` when applied;
+ * retries will happen indefinitely and adhere to the
+ * exponential backoff algorithm by multiplying by `backoffExponent`.
+ * For example, if `backoffExponent` is 10, the workflow will retry
+ * in 10s, 100s, 1000s, 10000s, etc.
+ *
+ * EXAMPLE | Using `maxSystemRetries = 3` and `backoffExponent = 10`, errant
+ * workflows will be retried on the following schedule (8 times in 27 hours):
+ * => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ */
+declare const getWorkflowYAML: (topic: string, version?: string, maxSystemRetries?: number, backoffExponent?: number) => string;
 declare const getActivityYAML: (topic: string, version?: string) => string;
 export { getActivityYAML, getWorkflowYAML };

package/build/services/durable/factory.js

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkflowYAML = exports.getActivityYAML = void 0;
-const getWorkflowYAML = (topic, version = '1') => {
+/**
+ * 1) `maxSystemRetries` | can be 0 to 3 and represents milliseconds;
+ * if there is an error, the workflow will retry up to `maxSystemRetries` times
+ * delaying by 10, 100, and 1000ms; this is a system level retry
+ * and is not configurable. It exists to handle intermittent network
+ * errors. (NOTE: each retry spawns a new transition stream)
+ *
+ * 2) `backoffExponent` | can be any number and represents `seconds` when applied;
+ * retries will happen indefinitely and adhere to the
+ * exponential backoff algorithm by multiplying by `backoffExponent`.
+ * For example, if `backoffExponent` is 10, the workflow will retry
+ * in 10s, 100s, 1000s, 10000s, etc.
+ *
+ * EXAMPLE | Using `maxSystemRetries = 3` and `backoffExponent = 10`, errant
+ * workflows will be retried on the following schedule (8 times in 27 hours):
+ * => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ */
+const getWorkflowYAML = (topic, version = '1', maxSystemRetries = 2, backoffExponent = 10) => {
     return `app:
   id: ${topic}
   version: '${version}'
@@ -33,10 +50,20 @@ const getWorkflowYAML = (topic, version = '1') => {
         a1:
           type: activity
           cycle: true
-  
+          output:
+            schema:
+              type: object
+              properties:
+                duration:
+                  type: number
+            maps:
+              duration: ${backoffExponent}
+
         w1:
           type: worker
           topic: ${topic}
+          retry:
+            '599': [${maxSystemRetries}]
           input:
             schema:
               type: object
@@ -58,18 +85,33 @@ const getWorkflowYAML = (topic, version = '1') => {
             maps:
               response: '{$self.output.data.response}'
 
+        a599:
+          title: Sleep before trying again
+          type: activity
+          sleep: "{a1.output.data.duration}"
+
         c1:
+          title: Goto Activity a1
           type: cycle
           ancestor: a1
+          input:
+            maps:
+              duration:
+                '@pipe':
+                  - ['{a1.output.data.duration}', ${backoffExponent}]
+                  - ['{@math.multiply}']
+
       transitions:
         t1:
           - to: a1
         a1:
           - to: w1
         w1:
-          - to: c1
+          - to: a599
             conditions:
-              code: 500
+              code: 599
+        a599:
+        - to: c1
 `;
 };
 exports.getWorkflowYAML = getWorkflowYAML;

package/build/services/durable/handle.js

@@ -10,22 +10,40 @@ class WorkflowHandleService {
     async result() {
         let status = await this.hotMesh.getStatus(this.workflowId);
         const topic = `${this.workflowTopic}.${this.workflowId}`;
-        if (status == 0) {
-            return (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response;
-        }
         return new Promise((resolve, reject) => {
             let isResolved = false;
             //common fulfill/unsubscribe
-            const complete = async (response) => {
+            const complete = async (response, err) => {
                 if (isResolved)
                     return;
                 isResolved = true;
                 this.hotMesh.unsub(topic);
-                resolve(response || (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response);
+                if (err) {
+                    return reject(JSON.parse(err));
+                }
+                else if (!response) {
+                    const state = await this.hotMesh.getState(this.workflowTopic, this.workflowId);
+                    if (!state.data && state.metadata.err) {
+                        return reject(JSON.parse(state.metadata.err));
+                    }
+                    response = state.data?.response;
+                }
+                resolve(response);
             };
-            this.hotMesh.sub(topic, async (topic, message) => {
-                await complete(message.data?.response);
+            //check for done
+            if (status == 0) {
+                return complete();
+            }
+            //subscribe to topic
+            this.hotMesh.sub(topic, async (topic, state) => {
+                if (!state.data && state.metadata.err) {
+                    await complete(null, state.metadata.err);
+                }
+                else {
+                    await complete(state.data?.response);
+                }
             });
+            //resolve for race condition
             setTimeout(async () => {
                 status = await this.hotMesh.getStatus(this.workflowId);
                 if (status == 0) {

package/build/services/durable/native.js

@@ -22,7 +22,6 @@ async function run() {
   });
   const worker = await Worker.create({
     connection,
-    namespace: 'default',
     taskQueue: 'hello-world',
     workflow: workflows.example,
     activities,

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

@@ -1,13 +1,13 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig } from "../../types/durable";
+import { Connection, Registry, WorkerConfig, WorkerOptions } from "../../types/durable";
 export declare class WorkerService {
     static activityRegistry: Registry;
     static connection: Connection;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     workflowRunner: HotMesh;
     activityRunner: HotMesh;
-    static getHotMesh: (worflowTopic: string) => Promise<HotMesh>;
-    static activateWorkflow(hotMesh: HotMesh, topic: string, factory: Function): Promise<void>;
+    static getHotMesh: (worflowTopic: string, options?: WorkerOptions) => Promise<HotMesh>;
+    static activateWorkflow(hotMesh: HotMesh, topic: string, dagFactory: Function, options?: WorkerOptions): Promise<void>;
     /**
      * The `worker` calls `registerActivities` immediately BEFORE
      * dynamically importing the user's workflow module. That file