@hotmeshio/hotmesh 0.1.8 → 0.1.9

package/build/modules/utils.d.ts

@@ -5,6 +5,7 @@ import { RedisClient, RedisMulti } from '../types/redis';
 import { StringAnyType } from '../types/serializer';
 import { StreamCode, StreamStatus } from '../types/stream';
 import { SystemHealth } from '../types/quorum';
+export declare const hashOptions: (options: any) => string;
 export declare function getSystemHealth(): Promise<SystemHealth>;
 export declare function sleepFor(ms: number): Promise<unknown>;
 export declare function sleepImmediate(): Promise<void>;

package/build/modules/utils.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.guid = exports.deepCopy = exports.sleepImmediate = exports.sleepFor = exports.getSystemHealth = void 0;
+exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.guid = exports.deepCopy = exports.sleepImmediate = exports.sleepFor = exports.getSystemHealth = exports.hashOptions = void 0;
 const os_1 = __importDefault(require("os"));
+const crypto_1 = require("crypto");
 const nanoid_1 = require("nanoid");
 const enums_1 = require("./enums");
 async function safeExecute(operation, defaultValue) {
@@ -16,10 +17,17 @@ async function safeExecute(operation, defaultValue) {
         return defaultValue;
     }
 }
+const hashOptions = (options) => {
+    const str = JSON.stringify(options);
+    return (0, crypto_1.createHash)('sha256').update(str).digest('hex');
+};
+exports.hashOptions = hashOptions;
 async function getSystemHealth() {
     const totalMemory = os_1.default.totalmem();
     const freeMemory = os_1.default.freemem();
     const usedMemory = totalMemory - freeMemory;
+    //NOTE: enable the following if desired; for now, only
+    //      `memory` is emitted when system health is requested
     //const cpus = os.cpus();
     // CPU load calculation remains unchanged
     // const cpuLoad = cpus.map((cpu, i) => {
@@ -28,9 +36,8 @@ async function getSystemHealth() {
     //   const usage = ((total - idle) / total) * 100;
     //   return { [`CPU ${i} Usage`]: `${usage.toFixed(2)}%` };
     // });
-    // Wrap each systeminformation call with safeExecute
+    // Wrap each systeminformation call with safeExecute (systeminformation npm package)
     //const networkStats = await safeExecute(si.networkStats(), []);
-    // Construct the system health object with error handling in mind
     const systemHealth = {
         TotalMemoryGB: `${(totalMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
         FreeMemoryGB: `${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -84,7 +84,6 @@
         "js-yaml": "^4.1.0",
         "ms": "^2.1.3",
         "nanoid": "^3.3.6",
-        "systeminformation": "^5.22.2",
         "winston": "^3.8.2"
     },
     "devDependencies": {

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

@@ -27,19 +27,17 @@ declare class Activity {
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     setLeg(leg: ActivityLeg): void;
     /**
-     * Upon entering leg 1 of a duplexed activty, verify
-     * all aspects of the entry including job and activty state
+     * Upon entering leg 1 of a duplexed activity
      */
     verifyEntry(): Promise<void>;
     /**
-     * Upon entering leg 2 of a duplexed activty, verify
-     * all aspects of the re-entry including job and activty state
+     * Upon entering leg 2 of a duplexed activity
      */
     verifyReentry(): Promise<number>;
     processEvent(status?: StreamStatus, code?: StreamCode, type?: 'hook' | 'output'): Promise<void>;
-    processPending(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
-    processSuccess(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
-    processError(telemetry: TelemetryService, type: string): Promise<MultiResponseFlags>;
+    processPending(type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processSuccess(type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processError(): Promise<MultiResponseFlags>;
     transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;

package/build/services/activities/activity.js

@@ -31,8 +31,7 @@ class Activity {
         this.leg = leg;
     }
     /**
-     * Upon entering leg 1 of a duplexed activty, verify
-     * all aspects of the entry including job and activty state
+     * Upon entering leg 1 of a duplexed activity
      */
     async verifyEntry() {
         this.setLeg(1);
@@ -41,8 +40,7 @@ class Activity {
         await collator_1.CollatorService.notarizeEntry(this);
     }
     /**
-     * Upon entering leg 2 of a duplexed activty, verify
-     * all aspects of the re-entry including job and activty state
+     * Upon entering leg 2 of a duplexed activity
      */
     async verifyReentry() {
         const guid = this.context.metadata.guid;
@@ -79,13 +77,13 @@ class Activity {
             telemetry.startActivitySpan(this.leg);
             let multiResponse;
             if (status === stream_1.StreamStatus.PENDING) {
-                multiResponse = await this.processPending(telemetry, type);
+                multiResponse = await this.processPending(type);
             }
             else if (status === stream_1.StreamStatus.SUCCESS) {
-                multiResponse = await this.processSuccess(telemetry, type);
+                multiResponse = await this.processSuccess(type);
             }
             else {
-                multiResponse = await this.processError(telemetry, type);
+                multiResponse = await this.processError();
             }
             this.transitionAdjacent(multiResponse, telemetry);
         }
@@ -120,7 +118,7 @@ class Activity {
             this.logger.debug('activity-process-event-end', { jid, aid });
         }
     }
-    async processPending(telemetry, type) {
+    async processPending(type) {
         this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
@@ -130,7 +128,7 @@ class Activity {
         await this.setStatus(this.adjacencyList.length, multi);
         return (await multi.exec());
     }
-    async processSuccess(telemetry, type) {
+    async processSuccess(type) {
         this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
@@ -140,7 +138,7 @@ class Activity {
         await this.setStatus(this.adjacencyList.length - 1, multi);
         return (await multi.exec());
     }
-    async processError(telemetry, type) {
+    async processError() {
         this.bindActivityError(this.data);
         this.adjacencyList = await this.filterAdjacent();
         if (!this.adjacencyList.length) {

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

@@ -20,7 +20,7 @@ export declare class ClientService {
      * creating the stream. This method will verify that the stream
      * exists and if not, create it.
      */
-    static verifyStream: (workflowTopic: string, namespace?: string) => Promise<HotMesh>;
+    verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
     search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
     workflow: {
         start: (options: WorkflowOptions) => Promise<WorkflowHandleService>;

package/build/services/durable/client.js

@@ -17,15 +17,14 @@ const factory_1 = require("./schemas/factory");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (workflowTopic, namespace) => {
+            //namespace isolation requires the connection options to be hashed
+            //as multiple intersecting databases can be used by the same service
+            const optionsHash = (0, utils_1.hashOptions)(this.connection.options);
             const targetNS = namespace ?? factory_1.APP_ID;
-            if (ClientService.instances.has(targetNS)) {
-                const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
-                const hotMeshClient = await ClientService.instances.get(targetNS);
+            const connectionNS = `${optionsHash}.${targetNS}`;
+            if (ClientService.instances.has(connectionNS)) {
+                const hotMeshClient = await ClientService.instances.get(connectionNS);
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
-                if (!ClientService.topics.includes(targetTopic)) {
-                    ClientService.topics.push(targetTopic);
-                    await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
-                }
                 return hotMeshClient;
             }
             //create and cache an instance
@@ -39,11 +38,24 @@ class ClientService {
                     },
                 },
             });
-            ClientService.instances.set(targetNS, hotMeshClient);
-            await ClientService.createStream(await hotMeshClient, workflowTopic, namespace);
+            ClientService.instances.set(connectionNS, hotMeshClient);
             await this.activateWorkflow(await hotMeshClient, targetNS);
             return hotMeshClient;
         };
+        /**
+         * It is possible for a client to invoke a workflow without first
+         * creating the stream. This method will verify that the stream
+         * exists and if not, create it.
+         */
+        this.verifyStream = async (hotMeshClient, workflowTopic, namespace) => {
+            const optionsHash = (0, utils_1.hashOptions)(this.connection.options);
+            const targetNS = namespace ?? factory_1.APP_ID;
+            const targetTopic = `${optionsHash}.${targetNS}.${workflowTopic}`;
+            if (!ClientService.topics.includes(targetTopic)) {
+                ClientService.topics.push(targetTopic);
+                await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
+            }
+        };
         this.search = async (hotMeshClient, index, query) => {
             const store = hotMeshClient.engine.store;
             if (query[0]?.startsWith('FT.')) {
@@ -57,10 +69,11 @@ class ClientService {
                 const workflowName = options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
-                //NOTE: HotMesh 'workflowTopic' is a created by concatenating
-                //     the taskQueue and workflowName used by the Durable module
+                //hotmesh topic is a combination of the durable queue+workflowname
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+                //verify that the stream channel exists before enqueueing
+                await this.verifyStream(hotMeshClient, workflowTopic, options.namespace);
                 const payload = {
                     arguments: [...options.args],
                     originJobId: options.originJobId,
@@ -200,21 +213,4 @@ ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) =>
         //ignore if already exists
     }
 };
-/**
- * It is possible for a client to invoke a workflow without first
- * creating the stream. This method will verify that the stream
- * exists and if not, create it.
- */
-ClientService.verifyStream = async (workflowTopic, namespace) => {
-    const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
-    const targetNS = namespace ?? factory_1.APP_ID;
-    if (ClientService.instances.has(targetNS)) {
-        const hotMeshClient = await ClientService.instances.get(targetNS);
-        if (!ClientService.topics.includes(targetTopic)) {
-            ClientService.topics.push(targetTopic);
-            await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
-        }
-        return hotMeshClient;
-    }
-};
 exports.ClientService = ClientService;

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

@@ -1,13 +1,11 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
+import { Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
 export declare class WorkerService {
     static activityRegistry: Registry;
-    static connections: Map<string, import("../../types/durable").ConnectionConfig>;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     workflowRunner: HotMesh;
     activityRunner: HotMesh;
     static getHotMesh: (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => Promise<HotMesh>;
-    static findConnectionByNamespace: (namespace: string) => Connection;
     static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     static registerActivities<ACT>(activities: ACT): Registry;
     static create(config: WorkerConfig): Promise<WorkerService>;

package/build/services/durable/worker.js

@@ -58,8 +58,6 @@ class WorkerService {
         return WorkerService.activityRegistry;
     }
     static async create(config) {
-        const targetNamespace = config.namespace ?? factory_1.APP_ID;
-        WorkerService.connections.set(targetNamespace, config.connection);
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
@@ -94,9 +92,12 @@ class WorkerService {
             class: config.connection.class,
             options: config.connection.options,
         };
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-            appId: config.namespace ?? factory_1.APP_ID,
+            appId: targetNamespace,
             engine: { redis: redisConfig },
             workers: [
                 {
@@ -106,10 +107,9 @@ class WorkerService {
                 },
             ],
         });
-        WorkerService.instances.set(activityTopic, hotMeshWorker);
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
         return hotMeshWorker;
     }
-    //this is the linked worker function in the reentrant workflow test
     wrapActivityFunctions() {
         return async (data) => {
             try {
@@ -172,6 +172,9 @@ class WorkerService {
             class: config.connection.class,
             options: config.connection.options,
         };
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
@@ -184,7 +187,7 @@ class WorkerService {
                 },
             ],
         });
-        WorkerService.instances.set(workflowTopic, hotMeshWorker);
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
         return hotMeshWorker;
     }
     wrapWorkflowFunction(workflowFunction, workflowTopic, config) {
@@ -199,6 +202,7 @@ class WorkerService {
                 context.set('canRetry', workflowInput.canRetry);
                 context.set('counter', counter);
                 context.set('interruptionRegistry', interruptionRegistry);
+                context.set('connection', config.connection);
                 context.set('namespace', config.namespace ?? factory_1.APP_ID);
                 context.set('raw', data);
                 context.set('workflowId', workflowInput.workflowId);
@@ -372,11 +376,11 @@ class WorkerService {
 }
 _a = WorkerService;
 WorkerService.activityRegistry = {}; //user's activities
-WorkerService.connections = new Map();
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     const targetNamespace = config?.namespace ?? factory_1.APP_ID;
-    const targetTopic = `${targetNamespace}.${workflowTopic}`;
+    const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+    const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
     if (WorkerService.instances.has(targetTopic)) {
         return await WorkerService.instances.get(targetTopic);
     }
@@ -384,25 +388,13 @@ WorkerService.getHotMesh = async (workflowTopic, config, options) => {
         logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
         appId: targetNamespace,
         engine: {
-            redis: { ...WorkerService.findConnectionByNamespace(targetNamespace) },
+            redis: { ...config?.connection },
         },
     });
     WorkerService.instances.set(targetTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
 };
-WorkerService.findConnectionByNamespace = (namespace) => {
-    let defaultConnection;
-    for (const [ns, value] of WorkerService.connections) {
-        if (ns === namespace) {
-            return value;
-        }
-        else if (!defaultConnection) {
-            defaultConnection = value;
-        }
-    }
-    return defaultConnection;
-};
 WorkerService.Context = {
     info: () => {
         return {

package/build/services/durable/workflow.js

@@ -69,6 +69,7 @@ class WorkflowService {
         const interruptionRegistry = store.get('interruptionRegistry');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const originJobId = store.get('originJobId');
         const workflowTrace = store.get('workflowTrace');
@@ -82,6 +83,7 @@ class WorkflowService {
             counter: COUNTER.counter,
             cursor,
             interruptionRegistry,
+            connection,
             namespace,
             originJobId,
             raw,
@@ -100,8 +102,9 @@ class WorkflowService {
     static async getHotMesh() {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
-        return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        return await worker_1.WorkerService.getHotMesh(workflowTopic, { connection, namespace });
     }
     /**
      * Spawns a child workflow and awaits the return.
@@ -315,10 +318,12 @@ class WorkflowService {
         const workflowId = store.get('workflowId');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         //this ID is used as a item key with a hash (dash prefix ensures no collision)
@@ -347,8 +352,10 @@ class WorkflowService {
     static async signal(signalId, data) {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
@@ -365,8 +372,9 @@ class WorkflowService {
      * @param {HookOptions} options - the hook options
      */
     static async hook(options) {
-        const { workflowId, namespace, workflowTopic } = WorkflowService.getContext();
+        const { workflowId, connection, namespace, workflowTopic } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
@@ -395,13 +403,14 @@ class WorkflowService {
      * @template T - the result type
      */
     static async once(fn, ...args) {
-        const { COUNTER, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
+        const { COUNTER, connection, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const sessionId = `-once${workflowDimension}-${execIndex}-`;
         if (sessionId in replay) {
             return serializer_1.SerializerService.fromString(replay[sessionId]).data;
         }
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         const keyParams = {
@@ -424,8 +433,9 @@ class WorkflowService {
      * Interrupts a running job
      */
     static async interrupt(jobId, options = {}) {
-        const { workflowTopic, namespace } = WorkflowService.getContext();
+        const { workflowTopic, connection, namespace, } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {

package/build/types/durable.d.ts

@@ -88,6 +88,10 @@ type WorkflowContext = {
      * the native HotMesh message that encapsulates the arguments, metadata, and raw data for the workflow
      */
     raw: StreamData;
+    /**
+     * the HotMesh connection configuration (io/redis NPM package reference and login credentials)
+     */
+    connection: Connection;
 };
 /**
  * The schema for the full-text-search (RediSearch) index.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -84,7 +84,6 @@
     "js-yaml": "^4.1.0",
     "ms": "^2.1.3",
     "nanoid": "^3.3.6",
-    "systeminformation": "^5.22.2",
     "winston": "^3.8.2"
   },
   "devDependencies": {

package/types/durable.ts

@@ -106,6 +106,11 @@ type WorkflowContext = {
    * the native HotMesh message that encapsulates the arguments, metadata, and raw data for the workflow
    */
   raw: StreamData;
+
+  /**
+   * the HotMesh connection configuration (io/redis NPM package reference and login credentials)
+   */
+  connection: Connection;
 };
 
 /**