@hotmeshio/hotmesh 0.0.23 → 0.0.24

package/build/services/durable/meshos.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshOSService = void 0;
+const nanoid_1 = require("nanoid");
+const client_1 = require("./client");
+const search_1 = require("./search");
+const worker_1 = require("./worker");
+const _1 = require(".");
+const asyncLocalStorage_1 = require("./asyncLocalStorage");
+const workflow_1 = require("./workflow");
+/**
+ * The base class for running MeshOS workflows.
+ * Extend and register subclass methods by name to
+ * execute as durable workflows, backed by Redis.
+ */
+class MeshOSService {
+    static async getHotMeshClient(redisClass, redisOptions, namespace, taskQueue) {
+        const client = new client_1.ClientService({
+            connection: {
+                class: redisClass,
+                options: redisOptions,
+            }
+        });
+        return await client.getHotMeshClient(taskQueue, namespace);
+    }
+    /**
+     * mints a workflow ID, using the search prefix.
+     * NOTE: The prefix is necesary when indexing
+     *       HASHes when FT search is enabled.
+     * @returns {string}
+     */
+    static mintGuid() {
+        const my = new this();
+        return `${my.search?.prefix?.[0]}${(0, nanoid_1.nanoid)()}}`;
+    }
+    /**
+     * Creates an FT search index
+     */
+    static async createIndex() {
+        const my = new this();
+        const hmClient = await MeshOSService.getHotMeshClient(my.redisClass, my.redisOptions, my.namespace, my.taskQueue);
+        search_1.Search.configureSearchIndex(hmClient, my.search);
+    }
+    /**
+     * Initialize the worker(s) for the entity. This is a static
+     * method that allows for optional task Queue targeting.
+     * NOTE: Allow List may be optionally used to only wrap
+     *       specific methods in this class.
+     * @param {string} taskQueue
+     * @param {string[]} allowList
+     */
+    static async startWorkers(taskQueue, allowList = []) {
+        const my = new this();
+        //helper functions
+        const resolveFunctionNames = (arr) => arr.map(item => typeof item === 'string' ? item : item.name);
+        const belongsTo = (name, target) => {
+            const isWorkflow = target.find((item) => {
+                return typeof item === 'string' ? item === name : item.name === name;
+            });
+            return isWorkflow !== undefined;
+        };
+        // proxy registered activities
+        const proxyFunctionNames = resolveFunctionNames([...my.proxyFunctions]);
+        if (proxyFunctionNames.length) {
+            const proxyActivities = proxyFunctionNames.reduce((acc, funcName) => {
+                let originalMethod = my[funcName];
+                if (typeof originalMethod === 'function') {
+                    acc[funcName] = async (...args) => {
+                        return await originalMethod.apply(my, args);
+                    };
+                }
+                return acc;
+            }, {});
+            const proxiedActivities = _1.Durable.workflow.proxyActivities({
+                activities: proxyActivities
+            });
+            //WATCH!: unsure if this will pollute the scope; don't think
+            //      so as activity functions are terminal in the chain.
+            Object.assign(my, proxiedActivities);
+        }
+        const functionsToIterate = allowList.length ? resolveFunctionNames(allowList) : resolveFunctionNames([...my.workflowFunctions, ...my.hookFunctions]);
+        // Iterating through the functions sequentially
+        for (const funcName of functionsToIterate) {
+            const originalMethod = my[funcName];
+            if (typeof originalMethod === 'function') {
+                //wrap the function to return
+                const wrappedFunction = {
+                    [funcName]: async (...args) => {
+                        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+                        const workflowId = store.get('workflowId');
+                        //use a Proxy to wrap hook methods
+                        const context = new Proxy(my, {
+                            get: (target, prop, receiver) => {
+                                if (prop === 'id') {
+                                    return workflowId;
+                                }
+                                else if (typeof target[prop] === 'function') {
+                                    return (...args) => {
+                                        return new Promise(async (resolve, reject) => {
+                                            if (belongsTo(prop, my.hookFunctions)) {
+                                                return workflow_1.WorkflowService.hook({
+                                                    namespace: my.namespace,
+                                                    taskQueue: my.taskQueue,
+                                                    workflowName: prop,
+                                                    workflowId,
+                                                    args,
+                                                }).then(resolve).catch(reject);
+                                            }
+                                            //otherwise, call the method as a standard instance method.
+                                            target[prop].apply(this, args).then(resolve).catch(reject);
+                                        });
+                                    };
+                                }
+                                return Reflect.get(target, prop, receiver);
+                            },
+                        });
+                        return await originalMethod.apply(context, args);
+                    }
+                };
+                //start the worker
+                await worker_1.WorkerService.create({
+                    namespace: my.namespace,
+                    connection: {
+                        class: my.redisClass,
+                        options: my.redisOptions,
+                    },
+                    taskQueue: taskQueue ?? my.taskQueue,
+                    workflow: wrappedFunction,
+                });
+            }
+        }
+    }
+    /**
+     * executes the redis FT search query
+     * @example '@_quantity:[89 89]'
+     * @param {any[]} args
+     * @returns {string}
+     */
+    static async find(options, ...args) {
+        const my = new this();
+        const client = new client_1.ClientService({ connection: {
+                class: my.redisClass,
+                options: my.redisOptions
+            } });
+        //workflow name is the function name driving the workflow
+        let workflowName;
+        if (options?.workflowName) {
+            workflowName = options?.workflowName;
+        }
+        else if (my.workflowFunctions?.length) {
+            let target = my.workflowFunctions[0];
+            if (typeof target === 'string') {
+                workflowName = target;
+            }
+            else {
+                workflowName = target.name;
+            }
+        }
+        return await client.workflow.search(options?.taskQueue ?? my.taskQueue, workflowName, my.namespace, my.search.index, ...args); //[count, [id, fields[], id, fields[], id, fields[], ...]]
+    }
+    /**
+     * returns the workflow handle. The handle can then be
+     * used to query for status, state, custom state, etc.
+     * @param {string} id
+     * @returns {Promise<WorkflowHandleService>}
+     */
+    static async get(id) {
+        const my = new this();
+        const client = new client_1.ClientService({ connection: {
+                class: my.redisClass,
+                options: my.redisOptions
+            } });
+        let workflowName;
+        let target = my.workflowFunctions[0];
+        if (typeof target === 'string') {
+            workflowName = target;
+        }
+        else {
+            workflowName = target.name;
+        }
+        return await client.workflow.getHandle(my.taskQueue, workflowName, id, my.namespace);
+    }
+    /**
+     * Optionally include a target taskQueue to exec the
+     * workflow's call on a specific worker queue.
+     */
+    constructor(id, options) {
+        /**
+         * The top-level Redis isolation. All workflow data is
+         * isolated within this namespace. Values should be
+         * lower-case with no spaces (e.g, 'staging', 'prod', 'test',
+         * 'routing-stagig', 'reporting-prod', etc.).
+         *  1) only url-safe values are allowed;
+         *  2) the 'a' symbol is reserved by HotMesh for indexing apps
+         */
+        this.namespace = 'durable';
+        /**
+         * Data is routed to workers that specify this task queue.
+         * Setting the task queue when the worker is created will
+         * ensure that the worker only receives messages destined
+         * for the queue. Callers can specify the taskQue to when
+         * starting a job to call those workers.
+         */
+        this.taskQueue = 'default';
+        /**
+         * These methods run as durable workflows
+         */
+        this.workflowFunctions = [];
+        /**
+         * These methods run as hooks (hook into a running workflow)
+         */
+        this.hookFunctions = [];
+        /**
+         * These methods run as proxied activities (and are safely memoized)
+         */
+        this.proxyFunctions = [];
+        /**
+         * The Redis connection options. NOTE: Redis and IORedis
+         * use different formats for their connection config.
+         */
+        this.redisOptions = {
+            host: 'localhost',
+            port: 6379,
+            password: '',
+            db: 0,
+        };
+        this.id = id;
+        if (options?.taskQueue) {
+            this.taskQueue = options.taskQueue;
+        }
+        else if (!id && !options?.taskQueue) {
+            return this;
+        }
+        function belongsTo(name, target) {
+            const isWorkflow = target.find((item) => {
+                return typeof item === 'string' ? item === name : item.name === name;
+            });
+            return isWorkflow !== undefined;
+        }
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (typeof target[prop] === 'function') {
+                    return (...args) => {
+                        return new Promise(async (resolve, reject) => {
+                            const client = new client_1.ClientService({ connection: {
+                                    class: this.redisClass,
+                                    options: this.redisOptions
+                                } });
+                            if (belongsTo(prop, this.workflowFunctions)) {
+                                //start a new workflow
+                                const handle = await client.workflow.start({
+                                    namespace: this.namespace,
+                                    args,
+                                    taskQueue: this.taskQueue,
+                                    workflowName: prop,
+                                    workflowId: this.id,
+                                });
+                                if (options?.await) {
+                                    //wait for the workflow to complete
+                                    const result = await handle.result();
+                                    return resolve(result);
+                                }
+                                else {
+                                    //return the workflow handle
+                                    return resolve(handle);
+                                }
+                            }
+                            else if (belongsTo(prop, this.hookFunctions)) {
+                                //hook into a running workflow
+                                return client.workflow.hook({
+                                    namespace: this.namespace,
+                                    taskQueue: this.taskQueue,
+                                    workflowName: prop,
+                                    workflowId: this.id,
+                                    args,
+                                }).then(resolve).catch(reject);
+                            }
+                            //otherwise, call the method as a standard instance method.
+                            target[prop].apply(this, args).then(resolve).catch(reject);
+                        });
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+}
+MeshOSService.MeshOS = workflow_1.WorkflowService;
+exports.MeshOSService = MeshOSService;

package/build/services/durable/search.js

@@ -36,7 +36,6 @@ class Search {
                 await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
             }
             catch (err) {
-                console.error(err);
                 hotMeshClient.engine.logger.info('durable-client-search-err', { err });
             }
         }

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

@@ -10,7 +10,7 @@ export declare class WorkerService {
     static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     static registerActivities<ACT>(activities: ACT): Registry;
     static create(config: WorkerConfig): Promise<WorkerService>;
-    static resolveWorkflowTarget(workflow: object | Function): [string, Function];
+    static resolveWorkflowTarget(workflow: object | Function, name?: string): [string, Function];
     run(): Promise<void>;
     initActivityWorker(config: WorkerConfig, activityTopic: string): Promise<HotMesh>;
     wrapActivityFunctions(): Function;

package/build/services/durable/worker.js

@@ -41,6 +41,9 @@ class WorkerService {
                 if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
                     WorkerService.activityRegistry[activities[key].name] = activities[key];
                 }
+                else if (typeof activities[key] === 'function') {
+                    WorkerService.activityRegistry[key] = activities[key];
+                }
             });
         }
         return WorkerService.activityRegistry;
@@ -60,17 +63,18 @@ class WorkerService {
         await WorkerService.activateWorkflow(worker.workflowRunner);
         return worker;
     }
-    static resolveWorkflowTarget(workflow) {
+    static resolveWorkflowTarget(workflow, name) {
         let workflowFunction;
         if (typeof workflow === 'function') {
             workflowFunction = workflow;
+            return [workflowFunction.name ?? name, workflowFunction];
         }
         else {
             const workflowFunctionNames = Object.keys(workflow);
-            workflowFunction = workflow[workflowFunctionNames[workflowFunctionNames.length - 1]];
-            return WorkerService.resolveWorkflowTarget(workflowFunction);
+            const lastFunctionName = workflowFunctionNames[workflowFunctionNames.length - 1];
+            workflowFunction = workflow[lastFunctionName];
+            return WorkerService.resolveWorkflowTarget(workflowFunction, lastFunctionName);
         }
-        return [workflowFunction.name, workflowFunction];
     }
     async run() {
         this.workflowRunner.engine.logger.info('WorkerService is running');

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

@@ -18,6 +18,10 @@ export declare class WorkflowService {
      * return a search session for use when reading/writing to the workflow HASH
      */
     static search(): Promise<Search>;
+    /**
+     * return a handle to the hotmesh client currently running the workflow
+     */
+    static getHotMesh(): Promise<HotMesh>;
     /**
      * those methods that may only be called once must be protected by flagging
      * their execution with a unique key (the key is stored in the HASH alongside

package/build/services/durable/workflow.js

@@ -30,7 +30,7 @@ class WorkflowService {
         //this is risky but MUST be allowed. Users MAY set the workflowId,
         //but if there is a naming collision, the data from the target entity will be used
         //as there is know way of knowing if the item was generated via a prior run of the workflow
-        const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+        const childJobId = options.workflowId ?? `-${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
         const parentWorkflowId = `${workflowId}-f`;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
@@ -65,7 +65,7 @@ class WorkflowService {
         const workflowSpan = store.get('workflowSpan');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+        const childJobId = options.workflowId ?? `-${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
         const parentWorkflowId = `${workflowId}-f`;
         const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
         try {
@@ -122,6 +122,15 @@ class WorkflowService {
         const searchSessionId = `-search${workflowDimension}-${execIndex}`;
         return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
     }
+    /**
+     * return a handle to the hotmesh client currently running the workflow
+     */
+    static async getHotMesh() {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
+        const namespace = store.get('namespace');
+        return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+    }
     /**
      * those methods that may only be called once must be protected by flagging
      * their execution with a unique key (the key is stored in the HASH alongside
@@ -148,8 +157,11 @@ class WorkflowService {
      */
     static async signal(signalId, data) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
         const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(`${namespace}.wfs.signal`, { namespace });
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        //todo: this particular one is better patterned as a get/set,
+        //since the receipt is a meaningful string (the stream id)
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
             return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
         }
@@ -161,8 +173,9 @@ class WorkflowService {
      */
     static async hook(options) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
         const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
             const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
             const workflowId = options.workflowId ?? store.get('workflowId');
@@ -188,7 +201,7 @@ class WorkflowService {
         const workflowTopic = store.get('workflowTopic');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const namespace = store.get('namespace');
-        const sleepJobId = `${workflowId}-$sleep${workflowDimension}-${execIndex}`;
+        const sleepJobId = `-${workflowId}-$sleep${workflowDimension}-${execIndex}`;
         try {
             const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
             await hotMeshClient.getState(`${hotMeshClient.appId}.sleep.execute`, sleepJobId);
@@ -196,9 +209,8 @@ class WorkflowService {
             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)
+            // NOTE: If this message shows up in your stack trace, you forgot to await `Durable.workflow.sleep()` in your workflow code.
             throw new errors_1.DurableSleepError(workflowId, seconds, execIndex, workflowDimension);
         }
     }
@@ -216,7 +228,7 @@ class WorkflowService {
         const signalResults = [];
         for (const signal of signals) {
             const execIndex = COUNTER.counter = COUNTER.counter + 1;
-            const wfsJobId = `${workflowId}-$wfs${workflowDimension}-${execIndex}`;
+            const wfsJobId = `-${workflowId}-$wfs${workflowDimension}-${execIndex}`;
             try {
                 if (allAreComplete) {
                     const state = await hotMeshClient.getState(`${hotMeshClient.appId}.wfs.execute`, wfsJobId);
@@ -267,7 +279,7 @@ class WorkflowService {
             const spn = store.get('workflowSpan');
             const namespace = store.get('namespace');
             const activityTopic = `${workflowTopic}-activity`;
-            const activityJobId = `${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
+            const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
             let activityState;
             try {
                 const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic, { namespace });

package/build/services/signaler/stream.js

@@ -37,7 +37,7 @@ class StreamSignaler {
             await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
         }
         catch (err) {
-            this.logger.info('consumer-group-exists', { stream, group });
+            this.logger.debug('consumer-group-exists', { stream, group });
         }
     }
     async publishMessage(topic, streamData, multi) {
@@ -121,7 +121,6 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (error) {
-            console.error(error);
             this.logger.error(`stream-call-function-error`, { error });
             output = this.structureUnhandledError(input, error);
         }

package/build/services/store/clients/ioredis.js

@@ -45,7 +45,7 @@ class IORedisStoreService extends index_1.StoreService {
                 return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
             }
             catch (err) {
-                this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                this.logger.debug(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
                 throw err;
             }
         }
@@ -54,7 +54,7 @@ class IORedisStoreService extends index_1.StoreService {
                 return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
             }
             catch (err) {
-                this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+                this.logger.debug(`Consumer group not created for key: ${key} and group: ${groupName}`);
                 throw err;
             }
         }

package/build/services/store/clients/redis.js

@@ -68,7 +68,7 @@ class RedisStoreService extends index_1.StoreService {
         }
         catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+            this.logger.debug(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
             throw error;
         }
     }

package/build/types/durable.d.ts

@@ -10,7 +10,7 @@ type WorkflowSearchOptions = {
     prefix?: string[];
     schema?: Record<string, {
         type: 'TEXT' | 'NUMERIC' | 'TAG';
-        sortable: boolean;
+        sortable?: boolean;
     }>;
     data?: Record<string, string>;
 };
@@ -52,13 +52,13 @@ type WorkflowDataType = {
     workflowId: string;
     workflowTopic: string;
 };
-type MeshDBClassConfig = {
+type MeshOSClassConfig = {
     namespace: string;
     taskQueue: string;
     redisOptions: RedisOptions;
     redisClass: RedisClass;
 };
-type MeshDBConfig = {
+type MeshOSConfig = {
     taskQueue?: string;
     index?: {
         index: string;
@@ -84,10 +84,24 @@ type WorkerConfig = {
     connection: Connection;
     namespace?: string;
     taskQueue: string;
-    workflow: Function;
+    workflow: Function | Record<string | symbol, Function>;
     options?: WorkerOptions;
     search?: WorkflowSearchOptions;
 };
+type FindOptions = {
+    workflowName?: string;
+    taskQueue?: string;
+    namespace?: string;
+    index?: string;
+};
+type MeshOSOptions = {
+    name: string;
+    options: WorkerOptions;
+};
+type MeshOSActivityOptions = {
+    name: string;
+    options: ActivityConfig;
+};
 type WorkerOptions = {
     logLevel?: string;
     maxSystemRetries?: number;
@@ -111,4 +125,4 @@ type ActivityConfig = {
         maximumInterval: string;
     };
 };
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyType, Registry, SignalOptions, HookOptions, MeshDBClassConfig, MeshDBConfig, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, };
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyType, Registry, SignalOptions, FindOptions, HookOptions, MeshOSActivityOptions, MeshOSClassConfig, MeshOSConfig, MeshOSOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, };

package/build/types/index.d.ts

@@ -3,7 +3,7 @@ export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyType, Registry, HookOptions, MeshDBClassConfig, MeshDBConfig, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyType, Registry, SignalOptions, FindOptions, HookOptions, MeshOSActivityOptions, MeshOSClassConfig, MeshOSConfig, MeshOSOptions, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
 export { RedisClientType as IORedisClientType, RedisMultiType as IORedisMultiType } from './ioredisclient';
 export { ILogger } from './logger';

package/index.ts

@@ -1,5 +1,6 @@
 import { Durable } from './services/durable';
+import { MeshOSService as MeshOS } from './services/durable/meshos';
 import { HotMeshService as HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
 
-export { Durable, HotMesh, HotMeshConfig };
+export { Durable, HotMesh, HotMeshConfig, MeshOS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -43,7 +43,7 @@
     "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:meshdb": "NODE_ENV=test jest ./tests/durable/meshdb/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:meshos": "NODE_ENV=test jest ./tests/durable/meshos/index.test.ts --detectOpenHandles --forceExit --verbose",
     "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:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",

package/services/durable/factory.ts

@@ -264,11 +264,11 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               cycleWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfc', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$wfc', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
                   - ['{@string.concat}']
               baseWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfs', '{sig.output.metadata.dad}', '-']
+                  - ['-', '{$job.metadata.jid}', '-$wfs', '{sig.output.metadata.dad}', '-']
                   - ['{@string.concat}']
           output:
             schema:
@@ -312,7 +312,7 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               workflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$sleep', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$sleep', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
                   - ['{@string.concat}']
           output:
             schema:
@@ -382,11 +382,11 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               cycleWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfc-', '{w1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$wfc-', '{w1.output.data.index}']
                   - ['{@string.concat}']
               baseWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfs-']
+                  - ['-', '{$job.metadata.jid}', '-$wfs-']
                   - ['{@string.concat}']
           output:
             schema:
@@ -430,7 +430,7 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               workflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$sleep-', '{w1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$sleep-', '{w1.output.data.index}']
                   - ['{@string.concat}']
           output:
             schema:

package/services/durable/handle.ts

@@ -39,10 +39,8 @@ export class WorkflowHandleService {
         throw new Error(JSON.parse(state.metadata.err));
       }
       if (state?.data?.done) {
-        //child flows are never technically 'done' as they have an open hook
-        //that is tied to the parent flow's completion. so, we need to check
-        //the 'done' flag on the child flow's payload (not the 'js' metadata field
-        //which is typically used); the `loadState` parameter triggers this
+        //child flows are never 'done'; they use a hook
+        //that only closes upon parent flow completion.
         return state.data.response;
       }
     }