@hotmeshio/hotmesh 0.0.22 → 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.d.ts

@@ -1,6 +1,7 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { StoreService } from '../store';
+import { WorkflowSearchOptions } from '../../types/durable';
 export declare class Search {
     jobId: string;
     searchSessionId: string;
@@ -8,6 +9,14 @@ export declare class Search {
     hotMeshClient: HotMesh;
     store: StoreService<RedisClient, RedisMulti> | null;
     safeKey(key: string): string;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. However, all values are still available
+     * in the HASH.
+     */
+    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
     constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string);
     /**
      * increments the index to return a unique search session guid when

package/build/services/durable/search.js

@@ -4,10 +4,42 @@ exports.Search = void 0;
 const key_1 = require("../../modules/key");
 class Search {
     safeKey(key) {
-        //note: protect the execution namespace with a prefix,
-        //so its design never conflicts with the hotmesh keyspace
+        //note: protect the execution namespace with a prefix
         return `_${key}`;
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. However, all values are still available
+     * in the HASH.
+     */
+    static async configureSearchIndex(hotMeshClient, search) {
+        if (search?.schema) {
+            const store = hotMeshClient.engine.store;
+            const schema = [];
+            for (const [key, value] of Object.entries(search.schema)) {
+                //prefix with a comma (avoids collisions with hotmesh reserved words)
+                schema.push(`_${key}`);
+                schema.push(value.type);
+                if (value.sortable) {
+                    schema.push('SORTABLE');
+                }
+            }
+            try {
+                const keyParams = {
+                    appId: hotMeshClient.appId,
+                    jobId: ''
+                };
+                const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+                const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
+                await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
+            }
+            catch (err) {
+                hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+            }
+        }
+    }
     constructor(workflowId, hotMeshClient, searchSessionId) {
         this.searchSessionIndex = 0;
         const keyParams = {

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

@@ -1,5 +1,5 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions, WorkflowSearchOptions } from '../../types/durable';
+import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
 export declare class WorkerService {
     static activityRegistry: Registry;
     static connection: Connection;
@@ -9,16 +9,8 @@ export declare class WorkerService {
     static getHotMesh: (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => Promise<HotMesh>;
     static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     static registerActivities<ACT>(activities: ACT): Registry;
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow. For all
-     * others, this method will fail gracefully. In all cases, the values
-     * will be stored in the workflow's central HASH data structure, allowing
-     * for manual traversal and inspection as well.
-     */
-    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
     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

@@ -3,10 +3,10 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const errors_1 = require("../../modules/errors");
-const key_1 = require("../../modules/key");
 const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
+const search_1 = require("./search");
 const stream_1 = require("../../types/stream");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
@@ -41,43 +41,13 @@ 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;
     }
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow. For all
-     * others, this method will fail gracefully. In all cases, the values
-     * will be stored in the workflow's central HASH data structure, allowing
-     * for manual traversal and inspection as well.
-     */
-    static async configureSearchIndex(hotMeshClient, search) {
-        if (search?.schema) {
-            const store = hotMeshClient.engine.store;
-            const schema = [];
-            for (const [key, value] of Object.entries(search.schema)) {
-                //prefix with a comma (avoids collisions with hotmesh reserved words)
-                schema.push(`_${key}`);
-                schema.push(value.type);
-                if (value.sortable) {
-                    schema.push('SORTABLE');
-                }
-            }
-            try {
-                const keyParams = {
-                    appId: hotMeshClient.appId,
-                    jobId: ''
-                };
-                const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-                const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
-                await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
-            }
-            catch (err) {
-                hotMeshClient.engine.logger.info('durable-client-search-err', { err });
-            }
-        }
-    }
     static async create(config) {
         WorkerService.connection = config.connection;
         const workflow = config.workflow;
@@ -89,21 +59,22 @@ class WorkerService {
         const worker = new WorkerService();
         worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
         worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
-        WorkerService.configureSearchIndex(worker.workflowRunner, config.search);
+        search_1.Search.configureSearchIndex(worker.workflowRunner, config.search);
         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

@@ -10,11 +10,22 @@ export declare class WorkflowService {
      * spawn a child workflow. return the childJobId.
      */
     static startChild<T>(options: WorkflowOptions): Promise<string>;
+    /**
+     * wrap all activities in a proxy that will durably run them
+     */
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
+    /**
+     * 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 workflow state)
+     * their execution with a unique key (the key is stored in the HASH alongside
+     * process state and job state)
      */
     static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
     /**

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 {
@@ -89,6 +89,9 @@ class WorkflowService {
             return childJobId;
         }
     }
+    /**
+     * wrap all activities in a proxy that will durably run them
+     */
     static proxyActivities(options) {
         if (options.activities) {
             worker_1.WorkerService.registerActivities(options.activities);
@@ -103,6 +106,9 @@ class WorkflowService {
         }
         return proxy;
     }
+    /**
+     * return a search session for use when reading/writing to the workflow HASH
+     */
     static async search() {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
         const workflowId = store.get('workflowId');
@@ -111,14 +117,24 @@ class WorkflowService {
         const namespace = store.get('namespace');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        //this ID is used as a item key with a hash (dash prefix ensures no collision)
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        //this ID is used as a item key with a hash (dash prefix ensures no collision)
         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 workflow state)
+     * their execution with a unique key (the key is stored in the HASH alongside
+     * process state and job state)
      */
     static async isSideEffectAllowed(hotMeshClient, prefix) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
@@ -126,15 +142,12 @@ class WorkflowService {
         const workflowDimension = store.get('workflowDimension') ?? '';
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        //this ID is used as a item key with a hash (dash prefix ensures no collision)
         const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
-        //this ID is used as a item key with a hash (dash prefix ensures no collision)
         const keyParams = {
             appId: hotMeshClient.appId,
-            jobId: ''
+            jobId: workflowId
         };
-        const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const workflowGuid = `${hotMeshPrefix}${workflowId}`;
+        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
         const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
         return guidValue === 1;
     }
@@ -144,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 });
         }
@@ -157,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');
@@ -184,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);
@@ -192,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);
         }
     }
@@ -212,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);
@@ -263,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/engine/index.d.ts

@@ -18,6 +18,7 @@ import { JobState, JobData, JobMetadata, JobOutput, JobStatus } from '../../type
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
+import { StringAnyType } from '../../types/serializer';
 import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
 declare class EngineService {
@@ -82,6 +83,7 @@ declare class EngineService {
     runJobCompletionTasks(context: JobState, emit?: boolean): Promise<void>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;
+    getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
     compress(terms: string[]): Promise<boolean>;
 }
 export { EngineService };

package/build/services/engine/index.js

@@ -523,6 +523,9 @@ class EngineService {
         }
         return stateTree;
     }
+    async getQueryState(jobId, fields) {
+        return await this.store.getQueryState(jobId, fields);
+    }
     async compress(terms) {
         const existingSymbols = await this.store.getSymbolValues();
         const startIndex = Object.keys(existingSymbols).length;