@hotmeshio/hotmesh 0.0.38 → 0.0.40

package/README.md

@@ -19,8 +19,17 @@ HotMesh inverts the relationship to Redis: those functions that once used Redis
 
 HotMesh creates an *ad hoc*, Redis-backed network of functions and organizes them into a unified service mesh. *Any service with access to Redis can join in the network, bypassing the legacy clutter.*
 
+<img src="./docs/img/hotmesh_emergent_properties.png" alt="HotMesh elevates Redis to a Service Mesh, Message Router, Integration Bus, and Business Process Engine." style="max-width:100%;width:600px;">
+
+
 ## Design
-The simplest way to get started is to use the `Durable` module. It's organized using principles similar to temporal.io. If you're familiar with their SDK, the setup is similar.
+HotMesh uses your existing Redis installation. If you already have an instance available, you have all the infrastructure you'll ever need.
+
+### Design | Pluck
+The simplest way to get started is to use the [HotMesh Pluck](https://github.com/hotmeshio/pluck-typescript) package. It's designed for usability, and is backed by the HotMesh system if you need advanced features. It includes a detailed [SDK](https://hotmeshio.github.io/pluck-typescript/) and a wide variety of examples.
+
+### Design | Durable
+HotMesh's *Durable* module is a TypeScript Library modeled after Temporal.io. If you're familiar with their SDK, the principles are the same.
 
 1. Start by defining **activities**. Activities 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
@@ -99,7 +108,7 @@ The simplest way to get started is to use the `Durable` module. It's organized u
     }
     ```
 
-### Workflow Extensions
+#### Workflow Extensions
 Redis governance delivers more than just reliability. Externalizing state fundamentally changes the execution profile for your functions, allowing you to design long-running, durable workflows. The `Durable` base class (shown in the examples above) provides additional methods for solving the most common state management challenges.
 
  - `waitForSignal` Pause your function and wait for external event(s) before continuing. The *waitForSignal* method will collate and cache the signals and only awaken your function once all signals have arrived.
@@ -177,8 +186,8 @@ Redis governance delivers more than just reliability. Externalizing state fundam
 
 Refer to the [hotmeshio/samples-typescript](https://github.com/hotmeshio/samples-typescript) repo for usage examples. 
 
-## 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.
+### Design | Advanced
+The *Pluck* and *Durable* modules are the easiest way to use HotMesh. 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.
 
 ```yaml
 app:
@@ -310,6 +319,3 @@ HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchest
 
 ## System Lifecycle
 Gain insight into HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/system_lifecycle.md).
-
-## Alpha Release
-So what exacty is an [alpha release](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/alpha.md)?

package/build/modules/enums.d.ts

@@ -1,23 +1,29 @@
-export declare const STATUS_CODE_SUCCESS = 200;
-export declare const STATUS_CODE_PENDING = 202;
-export declare const STATUS_CODE_TIMEOUT = 504;
-export declare const STATUS_CODE_INTERRUPT = 410;
-export declare const OTT_WAIT_TIME = 1000;
-export declare const MAX_RETRIES = 3;
-export declare const MAX_TIMEOUT_MS = 60000;
-export declare const GRADUATED_INTERVAL_MS = 5000;
-export declare const BLOCK_DURATION = 15000;
-export declare const TEST_BLOCK_DURATION = 1000;
-export declare const BLOCK_TIME_MS: number;
-export declare const XCLAIM_DELAY_MS: number;
-export declare const XCLAIM_COUNT = 3;
-export declare const XPENDING_COUNT = 10;
-export declare const STATUS_CODE_UNACKED = 999;
-export declare const STATUS_CODE_UNKNOWN = 500;
-export declare const STATUS_MESSAGE_UNKNOWN = "unknown";
-export declare const EXPIRE_DURATION = 15;
-export declare const BASE_FIDELITY_SECONDS = 15;
-export declare const TEST_FIDELITY_SECONDS = 5;
-export declare const FIDELITY_SECONDS: number;
-export declare const DURABLE_EXPIRE_SECONDS = 1;
-export declare const SCOUT_INTERVAL_SECONDS = 60;
+import { LogLevel } from "../types/logger";
+export declare const HMSH_LOGLEVEL: LogLevel;
+export declare const HMSH_CODE_SUCCESS = 200;
+export declare const HMSH_CODE_PENDING = 202;
+export declare const HMSH_CODE_NOTFOUND = 404;
+export declare const HMSH_CODE_INTERRUPT = 410;
+export declare const HMSH_CODE_UNKNOWN = 500;
+export declare const HMSH_CODE_TIMEOUT = 504;
+export declare const HMSH_CODE_UNACKED = 999;
+export declare const HMSH_CODE_DURABLE_SLEEPFOR = 592;
+export declare const HMSH_CODE_DURABLE_INCOMPLETE = 593;
+export declare const HMSH_CODE_DURABLE_WAITFOR = 594;
+export declare const HMSH_CODE_DURABLE_TIMEOUT = 596;
+export declare const HMSH_CODE_DURABLE_MAXED = 597;
+export declare const HMSH_CODE_DURABLE_FATAL = 598;
+export declare const HMSH_CODE_DURABLE_RETRYABLE = 599;
+export declare const HMSH_STATUS_UNKNOWN = "unknown";
+export declare const HMSH_OTT_WAIT_TIME: number;
+export declare const HMSH_EXPIRE_JOB_SECONDS: number;
+export declare const HMSH_MAX_RETRIES: number;
+export declare const HMSH_MAX_TIMEOUT_MS: number;
+export declare const HMSH_GRADUATED_INTERVAL_MS: number;
+export declare const HMSH_BLOCK_TIME_MS: number;
+export declare const HMSH_XCLAIM_DELAY_MS: number;
+export declare const HMSH_XCLAIM_COUNT: number;
+export declare const HMSH_XPENDING_COUNT: number;
+export declare const HMSH_EXPIRE_DURATION: number;
+export declare const HMSH_FIDELITY_SECONDS: number;
+export declare const HMSH_SCOUT_INTERVAL_SECONDS: number;

package/build/modules/enums.js

@@ -1,31 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCOUT_INTERVAL_SECONDS = exports.DURABLE_EXPIRE_SECONDS = exports.FIDELITY_SECONDS = exports.TEST_FIDELITY_SECONDS = exports.BASE_FIDELITY_SECONDS = exports.EXPIRE_DURATION = exports.STATUS_MESSAGE_UNKNOWN = exports.STATUS_CODE_UNKNOWN = exports.STATUS_CODE_UNACKED = exports.XPENDING_COUNT = exports.XCLAIM_COUNT = exports.XCLAIM_DELAY_MS = exports.BLOCK_TIME_MS = exports.TEST_BLOCK_DURATION = exports.BLOCK_DURATION = exports.GRADUATED_INTERVAL_MS = exports.MAX_TIMEOUT_MS = exports.MAX_RETRIES = exports.OTT_WAIT_TIME = exports.STATUS_CODE_INTERRUPT = exports.STATUS_CODE_TIMEOUT = exports.STATUS_CODE_PENDING = exports.STATUS_CODE_SUCCESS = void 0;
-// Engine Constants
-exports.STATUS_CODE_SUCCESS = 200;
-exports.STATUS_CODE_PENDING = 202;
-exports.STATUS_CODE_TIMEOUT = 504;
-exports.STATUS_CODE_INTERRUPT = 410;
-exports.OTT_WAIT_TIME = 1000;
-// Stream Constants
-exports.MAX_RETRIES = 3; //local retry; 10, 100, 1000ms
-exports.MAX_TIMEOUT_MS = 60000;
-exports.GRADUATED_INTERVAL_MS = 5000;
-exports.BLOCK_DURATION = 15000; //Set to `15` so SIGINT/SIGTERM can interrupt; set to `0` to BLOCK indefinitely
-exports.TEST_BLOCK_DURATION = 1000; //Set to `1000` so tests can interrupt quickly
-exports.BLOCK_TIME_MS = process.env.NODE_ENV === 'test' ? exports.TEST_BLOCK_DURATION : exports.BLOCK_DURATION;
-exports.XCLAIM_DELAY_MS = 1000 * 60; //max time a message can be unacked before it is claimed by another
-exports.XCLAIM_COUNT = 3; //max number of times a message can be claimed by another before it is dead-lettered
-exports.XPENDING_COUNT = 10;
-exports.STATUS_CODE_UNACKED = 999;
-exports.STATUS_CODE_UNKNOWN = 500;
-exports.STATUS_MESSAGE_UNKNOWN = 'unknown';
-// HotMesh Constants
-exports.EXPIRE_DURATION = 15; // default expire in seconds; once job state semaphore reaches '0', this is applied to set Redis to expire the job HASH
-exports.BASE_FIDELITY_SECONDS = 15; // granularity resolution window size
-exports.TEST_FIDELITY_SECONDS = 5;
-exports.FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? exports.TEST_FIDELITY_SECONDS : exports.BASE_FIDELITY_SECONDS;
-// DURABLE CONSTANTS
-exports.DURABLE_EXPIRE_SECONDS = 1;
-// TASK CONSTANTS
-exports.SCOUT_INTERVAL_SECONDS = 60;
+exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_DURABLE_RETRYABLE = exports.HMSH_CODE_DURABLE_FATAL = exports.HMSH_CODE_DURABLE_MAXED = exports.HMSH_CODE_DURABLE_TIMEOUT = exports.HMSH_CODE_DURABLE_WAITFOR = exports.HMSH_CODE_DURABLE_INCOMPLETE = exports.HMSH_CODE_DURABLE_SLEEPFOR = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_LOGLEVEL = void 0;
+// HOTMESH SYSTEM
+exports.HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL || 'info';
+// STATUS CODES AND MESSAGES
+exports.HMSH_CODE_SUCCESS = 200;
+exports.HMSH_CODE_PENDING = 202;
+exports.HMSH_CODE_NOTFOUND = 404;
+exports.HMSH_CODE_INTERRUPT = 410;
+exports.HMSH_CODE_UNKNOWN = 500;
+exports.HMSH_CODE_TIMEOUT = 504;
+exports.HMSH_CODE_UNACKED = 999;
+exports.HMSH_CODE_DURABLE_SLEEPFOR = 592;
+exports.HMSH_CODE_DURABLE_INCOMPLETE = 593;
+exports.HMSH_CODE_DURABLE_WAITFOR = 594;
+exports.HMSH_CODE_DURABLE_TIMEOUT = 596;
+exports.HMSH_CODE_DURABLE_MAXED = 597;
+exports.HMSH_CODE_DURABLE_FATAL = 598;
+exports.HMSH_CODE_DURABLE_RETRYABLE = 599;
+exports.HMSH_STATUS_UNKNOWN = 'unknown';
+// ENGINE
+exports.HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
+exports.HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
+// STREAM ROUTER
+exports.HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
+exports.HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
+exports.HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
+const BASE_BLOCK_DURATION = 10000; // Modified for clarity
+const TEST_BLOCK_DURATION = 1000; // Modified for clarity
+exports.HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS ? parseInt(process.env.HMSH_BLOCK_TIME_MS, 10) : (process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BASE_BLOCK_DURATION);
+exports.HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
+exports.HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
+exports.HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
+// TASK WORKER
+exports.HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
+const BASE_FIDELITY_SECONDS = 5;
+const TEST_FIDELITY_SECONDS = 5;
+exports.HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS ? parseInt(process.env.HMSH_FIDELITY_SECONDS, 10) : (process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS);
+exports.HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;

package/build/modules/errors.d.ts

@@ -2,7 +2,7 @@ import { ActivityDuplex } from "../types/activity";
 import { CollationFaultType, CollationStage } from "../types/collator";
 declare class GetStateError extends Error {
     jobId: string;
-    code: 404;
+    code: number;
     constructor(jobId: string);
 }
 declare class SetStateError extends Error {

package/build/modules/errors.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.GenerationalError = exports.ExecActivityError = exports.DuplicateJobError = exports.DurableWaitForSignalError = exports.DurableTimeoutError = exports.DurableSleepForError = exports.DurableSleepError = exports.DurableRetryError = exports.DurableMaxedError = exports.DurableIncompleteSignalError = exports.DurableFatalError = exports.CollationError = void 0;
+const enums_1 = require("./enums");
 class GetStateError extends Error {
     constructor(jobId) {
         super(`${jobId} Not Found`);
+        this.code = enums_1.HMSH_CODE_NOTFOUND;
         this.jobId = jobId;
     }
 }
@@ -19,7 +21,7 @@ exports.SetStateError = SetStateError;
 class DurableIncompleteSignalError extends Error {
     constructor(message) {
         super(message);
-        this.code = 593;
+        this.code = enums_1.HMSH_CODE_DURABLE_INCOMPLETE;
     }
 }
 exports.DurableIncompleteSignalError = DurableIncompleteSignalError;
@@ -28,7 +30,7 @@ class DurableWaitForSignalError extends Error {
     constructor(message, signals) {
         super(message);
         this.signals = signals;
-        this.code = 594;
+        this.code = enums_1.HMSH_CODE_DURABLE_WAITFOR;
     }
 }
 exports.DurableWaitForSignalError = DurableWaitForSignalError;
@@ -49,35 +51,35 @@ class DurableSleepForError extends Error {
         this.duration = duration;
         this.index = index;
         this.dimension = dimension;
-        this.code = 592;
+        this.code = enums_1.HMSH_CODE_DURABLE_SLEEPFOR;
     }
 }
 exports.DurableSleepForError = DurableSleepForError;
 class DurableTimeoutError extends Error {
     constructor(message) {
         super(message);
-        this.code = 596;
+        this.code = enums_1.HMSH_CODE_DURABLE_TIMEOUT;
     }
 }
 exports.DurableTimeoutError = DurableTimeoutError;
 class DurableMaxedError extends Error {
     constructor(message) {
         super(message);
-        this.code = 597;
+        this.code = enums_1.HMSH_CODE_DURABLE_MAXED;
     }
 }
 exports.DurableMaxedError = DurableMaxedError;
 class DurableFatalError extends Error {
     constructor(message) {
         super(message);
-        this.code = 598;
+        this.code = enums_1.HMSH_CODE_DURABLE_FATAL;
     }
 }
 exports.DurableFatalError = DurableFatalError;
 class DurableRetryError extends Error {
     constructor(message) {
         super(message);
-        this.code = 599;
+        this.code = enums_1.HMSH_CODE_DURABLE_RETRYABLE;
     }
 }
 exports.DurableRetryError = DurableRetryError;

package/build/modules/key.d.ts

@@ -1,3 +1,4 @@
+import { KeyStoreParams, KeyType } from '../types/hotmesh';
 /**
  * Keys
  *
@@ -26,40 +27,6 @@
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
 declare const HMNS = "hmsh";
-declare enum KeyType {
-    APP = "APP",
-    ENGINE_ID = "ENGINE",
-    HOOKS = "HOOKS",
-    JOB_DEPENDENTS = "JOB_DEPENDENTS",
-    JOB_STATE = "JOB_STATE",
-    JOB_STATS_GENERAL = "JOB_STATS_GENERAL",
-    JOB_STATS_MEDIAN = "JOB_STATS_MEDIAN",
-    JOB_STATS_INDEX = "JOB_STATS_INDEX",
-    HOTMESH = "HOTMESH",
-    QUORUM = "QUORUM",
-    SCHEMAS = "SCHEMAS",
-    SIGNALS = "SIGNALS",
-    STREAMS = "STREAMS",
-    SUBSCRIPTIONS = "SUBSCRIPTIONS",
-    SUBSCRIPTION_PATTERNS = "SUBSCRIPTION_PATTERNS",
-    SYMKEYS = "SYMKEYS",
-    SYMVALS = "SYMVALS",
-    TIME_RANGE = "TIME_RANGE",
-    WORK_ITEMS = "WORK_ITEMS"
-}
-type KeyStoreParams = {
-    appId?: string;
-    engineId?: string;
-    appVersion?: string;
-    jobId?: string;
-    activityId?: string;
-    jobKey?: string;
-    dateTime?: string;
-    facet?: string;
-    topic?: string;
-    timeValue?: number;
-    scoutType?: 'signal' | 'time';
-};
 declare class KeyService {
     /**
      * returns a key that can be used to access a value in the key/value store

package/build/modules/key.js

@@ -1,4 +1,8 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HMNS = exports.KeyType = exports.KeyService = void 0;
+const hotmesh_1 = require("../types/hotmesh");
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
 /**
  * Keys
  *
@@ -26,35 +30,8 @@
  * 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
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMNS = exports.KeyType = exports.KeyService = void 0;
-//default namespace for hotmesh
-const HMNS = "hmsh";
+const HMNS = "hmsh"; //default
 exports.HMNS = HMNS;
-//these are the entity types that are stored in the key/value store
-var KeyType;
-(function (KeyType) {
-    KeyType["APP"] = "APP";
-    KeyType["ENGINE_ID"] = "ENGINE";
-    KeyType["HOOKS"] = "HOOKS";
-    KeyType["JOB_DEPENDENTS"] = "JOB_DEPENDENTS";
-    KeyType["JOB_STATE"] = "JOB_STATE";
-    KeyType["JOB_STATS_GENERAL"] = "JOB_STATS_GENERAL";
-    KeyType["JOB_STATS_MEDIAN"] = "JOB_STATS_MEDIAN";
-    KeyType["JOB_STATS_INDEX"] = "JOB_STATS_INDEX";
-    KeyType["HOTMESH"] = "HOTMESH";
-    KeyType["QUORUM"] = "QUORUM";
-    KeyType["SCHEMAS"] = "SCHEMAS";
-    KeyType["SIGNALS"] = "SIGNALS";
-    KeyType["STREAMS"] = "STREAMS";
-    KeyType["SUBSCRIPTIONS"] = "SUBSCRIPTIONS";
-    KeyType["SUBSCRIPTION_PATTERNS"] = "SUBSCRIPTION_PATTERNS";
-    KeyType["SYMKEYS"] = "SYMKEYS";
-    KeyType["SYMVALS"] = "SYMVALS";
-    KeyType["TIME_RANGE"] = "TIME_RANGE";
-    KeyType["WORK_ITEMS"] = "WORK_ITEMS";
-})(KeyType || (KeyType = {}));
-exports.KeyType = KeyType;
 class KeyService {
     /**
      * returns a key that can be used to access a value in the key/value store
@@ -69,47 +46,47 @@ class KeyService {
      */
     static mintKey(namespace, keyType, params) {
         switch (keyType) {
-            case KeyType.HOTMESH:
+            case hotmesh_1.KeyType.HOTMESH:
                 return namespace;
-            case KeyType.ENGINE_ID:
+            case hotmesh_1.KeyType.ENGINE_ID:
                 return `${namespace}:${params.appId}:e:${params.engineId}`;
-            case KeyType.WORK_ITEMS:
+            case hotmesh_1.KeyType.WORK_ITEMS:
                 return `${namespace}:${params.appId}:w:${params.scoutType || ''}`;
-            case KeyType.TIME_RANGE:
+            case hotmesh_1.KeyType.TIME_RANGE:
                 return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
-            case KeyType.APP:
+            case hotmesh_1.KeyType.APP:
                 return `${namespace}:a:${params.appId || ''}`;
-            case KeyType.QUORUM:
+            case hotmesh_1.KeyType.QUORUM:
                 return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
-            case KeyType.JOB_STATE:
+            case hotmesh_1.KeyType.JOB_STATE:
                 return `${namespace}:${params.appId}:j:${params.jobId}`;
-            case KeyType.JOB_DEPENDENTS:
+            case hotmesh_1.KeyType.JOB_DEPENDENTS:
                 return `${namespace}:${params.appId}:d:${params.jobId}`;
-            case KeyType.JOB_STATS_GENERAL:
+            case hotmesh_1.KeyType.JOB_STATS_GENERAL:
                 return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
-            case KeyType.JOB_STATS_MEDIAN:
+            case hotmesh_1.KeyType.JOB_STATS_MEDIAN:
                 return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-            case KeyType.JOB_STATS_INDEX:
+            case hotmesh_1.KeyType.JOB_STATS_INDEX:
                 return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-            case KeyType.SCHEMAS:
+            case hotmesh_1.KeyType.SCHEMAS:
                 return `${namespace}:${params.appId}:v:${params.appVersion}:schemas`;
-            case KeyType.SUBSCRIPTIONS:
+            case hotmesh_1.KeyType.SUBSCRIPTIONS:
                 return `${namespace}:${params.appId}:v:${params.appVersion}:subscriptions`;
-            case KeyType.SUBSCRIPTION_PATTERNS:
+            case hotmesh_1.KeyType.SUBSCRIPTION_PATTERNS:
                 return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
-            case KeyType.HOOKS:
+            case hotmesh_1.KeyType.HOOKS:
                 //`hooks` provide the pattern to resolve a value
                 return `${namespace}:${params.appId}:hooks`;
-            case KeyType.SIGNALS:
+            case hotmesh_1.KeyType.SIGNALS:
                 //`signals` provide the registry of resolved values that link back to paused jobs
                 return `${namespace}:${params.appId}:signals`;
-            case KeyType.SYMKEYS:
+            case hotmesh_1.KeyType.SYMKEYS:
                 //`symbol keys` provide the registry of replacement values for job keys
                 return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
-            case KeyType.SYMVALS:
+            case hotmesh_1.KeyType.SYMVALS:
                 //`symbol vals` provide the registry of replacement values for job vals
                 return `${namespace}:${params.appId}:sym:vals:`;
-            case KeyType.STREAMS:
+            case hotmesh_1.KeyType.STREAMS:
                 return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;
             default:
                 throw new Error("Invalid key type.");

package/build/package.json

@@ -1,9 +1,9 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.38",
+    "version": "0.0.40",
     "description": "Unbreakable Workflows",
-    "main": "build/index.js",
-    "types": "build/index.d.ts",
+    "main": "./build/index.js",
+    "types": "./build/types/index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/hotmeshio/sdk-typescript.git"

package/build/services/activities/activity.js

@@ -346,7 +346,7 @@ class Activity {
         return context;
     }
     initPolicies(context) {
-        const expire = pipe_1.Pipe.resolve(this.config.expire ?? enums_1.EXPIRE_DURATION, context);
+        const expire = pipe_1.Pipe.resolve(this.config.expire ?? enums_1.HMSH_EXPIRE_DURATION, context);
         context.metadata.expire = expire;
     }
     bindActivityData(type) {

package/build/services/activities/hook.js

@@ -103,17 +103,12 @@ class Hook extends activity_1.Activity {
     }
     async registerHook(multi) {
         if (this.config.hook?.topic) {
-            const taskService = new task_1.TaskService(this.store, this.logger);
-            return await taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
+            return await this.engine.taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
         }
         else if (this.config.sleep) {
-            const durationInSeconds = pipe_1.Pipe.resolve(this.config.sleep, this.context);
-            const jobId = this.context.metadata.jid;
-            const gId = this.context.metadata.gid;
-            const activityId = this.metadata.aid;
-            const dId = this.metadata.dad;
-            await this.engine.taskService.registerTimeHook(jobId, gId, `${activityId}${dId || ''}`, 'sleep', durationInSeconds);
-            return jobId;
+            const duration = pipe_1.Pipe.resolve(this.config.sleep, this.context);
+            await this.engine.taskService.registerTimeHook(this.context.metadata.jid, this.context.metadata.gid, `${this.metadata.aid}${this.metadata.dad || ''}`, 'sleep', duration);
+            return this.context.metadata.jid;
         }
     }
     //********  SIGNAL RE-ENTRY POINT  ********//

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

@@ -18,9 +18,10 @@ declare class Trigger extends Activity {
     resolveJobKey(context: Partial<JobState>): string;
     setStateNX(): Promise<void>;
     /**
-     * Registers this job as a dependent of the parent job
+     * Registers this job as a dependent of the parent job; when the
+     * parent job is interrupted, this job will be interrupted
      */
-    setDependency(multi?: RedisMulti): Promise<void>;
+    registerJobDependency(multi?: RedisMulti): Promise<void>;
     setStats(multi?: RedisMulti): Promise<void>;
 }
 export { Trigger };

package/build/services/activities/trigger.js

@@ -29,7 +29,7 @@ class Trigger extends activity_1.Activity {
             const multi = this.store.getMulti();
             await this.setState(multi);
             await this.setStats(multi);
-            await this.setDependency(multi);
+            await this.registerJobDependency(multi);
             await multi.exec();
             telemetry.mapActivityAttributes();
             const jobStatus = Number(this.context.metadata.js);
@@ -152,13 +152,17 @@ class Trigger extends activity_1.Activity {
         }
     }
     /**
-     * Registers this job as a dependent of the parent job
+     * Registers this job as a dependent of the parent job; when the
+     * parent job is interrupted, this job will be interrupted
      */
-    async setDependency(multi) {
-        const depKey = this.config.stats?.parent;
-        const resolvedDepKey = depKey ? pipe_1.Pipe.resolve(depKey, this.context) : '';
+    async registerJobDependency(multi) {
+        const depKey = this.config.stats?.parent ?? this.context.metadata.pj;
+        let resolvedDepKey = depKey ? pipe_1.Pipe.resolve(depKey, this.context) : '';
+        if (!resolvedDepKey) {
+            resolvedDepKey = this.context.metadata.pj;
+        }
         if (resolvedDepKey) {
-            await this.store.setDependency(resolvedDepKey, this.context.metadata.tpc, this.context.metadata.jid, this.context.metadata.gid, multi);
+            await this.store.registerJobDependency(resolvedDepKey, this.context.metadata.tpc, this.context.metadata.jid, this.context.metadata.gid, multi);
         }
     }
     async setStats(multi) {

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

@@ -3,10 +3,18 @@ import { HotMeshService as HotMesh } from '../hotmesh';
 import { ClientConfig, Connection, HookOptions, WorkflowOptions, WorkflowSearchOptions } from '../../types/durable';
 export declare class ClientService {
     connection: Connection;
+    topics: string[];
     options: WorkflowOptions;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     constructor(config: ClientConfig);
-    getHotMeshClient: (worflowTopic: string, namespace?: string) => Promise<HotMesh>;
+    getHotMeshClient: (workflowTopic: string, namespace?: string) => Promise<HotMesh>;
+    /**
+     * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
+     * It is possible that the worker that will read from this stream channel
+     * has not yet been initialized, so this call ensures that the channel
+     * exists and is ready to serve as a container for events.
+     */
+    createStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
     /**
      * For those deployments with a redis stack backend (with the FT module),
      * this method will configure the search index for the workflow.

package/build/services/durable/client.js

@@ -10,13 +10,22 @@ const types_1 = require("../../types");
 const enums_1 = require("../../modules/enums");
 class ClientService {
     constructor(config) {
-        this.getHotMeshClient = async (worflowTopic, namespace) => {
-            //NOTE: every unique topic inits a new engine
-            if (ClientService.instances.has(worflowTopic)) {
-                return await ClientService.instances.get(worflowTopic);
+        this.topics = [];
+        this.getHotMeshClient = async (workflowTopic, namespace) => {
+            //use the cached instance
+            const instanceId = 'SINGLETON';
+            if (ClientService.instances.has(instanceId)) {
+                const hotMeshClient = await ClientService.instances.get(instanceId);
+                if (!this.topics.includes(workflowTopic)) {
+                    this.topics.push(workflowTopic);
+                    await this.createStream(hotMeshClient, workflowTopic, namespace);
+                }
+                return hotMeshClient;
             }
+            //create and cache an instance
             const hotMeshClient = hotmesh_1.HotMeshService.init({
                 appId: namespace ?? factory_1.APP_ID,
+                logLevel: enums_1.HMSH_LOGLEVEL,
                 engine: {
                     redis: {
                         class: this.connection.class,
@@ -24,10 +33,20 @@ class ClientService {
                     }
                 }
             });
-            ClientService.instances.set(worflowTopic, hotMeshClient);
-            //since the YAML topic is dynamic, it MUST be manually created before use
-            const store = (await hotMeshClient).engine.store;
-            const params = { appId: namespace ?? factory_1.APP_ID, topic: worflowTopic };
+            ClientService.instances.set(instanceId, hotMeshClient);
+            await this.createStream(await hotMeshClient, workflowTopic, namespace);
+            await this.activateWorkflow(await hotMeshClient, namespace ?? factory_1.APP_ID);
+            return hotMeshClient;
+        };
+        /**
+         * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
+         * It is possible that the worker that will read from this stream channel
+         * has not yet been initialized, so this call ensures that the channel
+         * exists and is ready to serve as a container for events.
+         */
+        this.createStream = async (hotMeshClient, workflowTopic, namespace) => {
+            const store = hotMeshClient.engine.store;
+            const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
             const streamKey = store.mintKey(key_1.KeyType.STREAMS, params);
             try {
                 await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
@@ -35,8 +54,6 @@ class ClientService {
             catch (err) {
                 //ignore if already exists
             }
-            await this.activateWorkflow(await hotMeshClient, namespace ?? factory_1.APP_ID);
-            return hotMeshClient;
         };
         /**
          * For those deployments with a redis stack backend (with the FT module),
@@ -89,7 +106,7 @@ class ClientService {
                 const payload = {
                     arguments: [...options.args],
                     originJobId: options.originJobId,
-                    expire: options.expire ?? enums_1.DURABLE_EXPIRE_SECONDS,
+                    expire: options.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS,
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMeshService.guid(),
                     workflowTopic: workflowTopic,
@@ -133,9 +150,8 @@ class ClientService {
                 if (options.search?.data) {
                     const searchSessionId = `-search-${hotmesh_1.HotMeshService.guid()}-0`;
                     const search = new search_1.Search(options.workflowId, hotMeshClient, searchSessionId);
-                    for (const [key, value] of Object.entries(options.search.data)) {
-                        search.set(key, value);
-                    }
+                    const entries = Object.entries(options.search.data).flat();
+                    await search.set(...entries);
                 }
                 return msgId;
             },

package/build/services/durable/handle.js

@@ -91,7 +91,7 @@ class WorkflowHandleService {
                     const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
                     if (state.metadata.err) {
                         const error = JSON.parse(state.metadata.err);
-                        if (error.code === enums_1.STATUS_CODE_INTERRUPT || !state.data) {
+                        if (error.code === enums_1.HMSH_CODE_INTERRUPT || !state.data) {
                             return reject({ ...error, job_id: this.workflowId });
                         }
                     }
@@ -107,7 +107,7 @@ class WorkflowHandleService {
             this.hotMesh.sub(topic, async (topic, state) => {
                 if (state.metadata.err) {
                     const error = JSON.parse(state.metadata.err);
-                    if (error.code === enums_1.STATUS_CODE_INTERRUPT || !state.data) {
+                    if (error.code === enums_1.HMSH_CODE_INTERRUPT || !state.data) {
                         return await complete(null, state.metadata.err);
                     }
                 }