@hotmeshio/hotmesh 0.1.15 → 0.1.17

package/build/services/meshdata/index.js

@@ -0,0 +1,541 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshData = void 0;
+const meshflow_1 = require("../meshflow");
+const hotmesh_1 = require("../hotmesh");
+const hotmesh_2 = require("../../types/hotmesh");
+class MeshData {
+    constructor(redisClass, redisOptions, search) {
+        this.connectionSignatures = {};
+        this.instances = new Map();
+        this.mesh = {
+            sub: async (callback, options = {}) => {
+                const hotMesh = await this.getHotMesh(options.namespace || 'durable');
+                const callbackWrapper = (topic, message) => {
+                    if (message.type === 'pong' && !message.originator) {
+                        if (message.profile?.worker_topic) {
+                            const [entity] = message.profile.worker_topic.split('-');
+                            if (entity) {
+                                message.profile.entity = message.entity = entity;
+                                if (this.connectionSignatures[entity]) {
+                                    message.profile.signature = this.connectionSignatures[entity];
+                                }
+                            }
+                        }
+                    }
+                    else if (message?.topic) {
+                        const [entity] = message.topic.split('-');
+                        if (entity) {
+                            message.entity = entity;
+                        }
+                    }
+                    callback(topic, message);
+                };
+                await hotMesh.quorum?.sub(callbackWrapper);
+            },
+            pub: async (message, options = {}) => {
+                const hotMesh = await this.getHotMesh(options.namespace || 'durable');
+                await hotMesh.quorum?.pub(message);
+            },
+            unsub: async (callback, options = {}) => {
+                const hotMesh = await this.getHotMesh(options.namespace || 'durable');
+                await hotMesh.quorum?.unsub(callback);
+            }
+        };
+        this.redisClass = redisClass;
+        this.redisOptions = redisOptions;
+        if (search) {
+            this.search = search;
+        }
+    }
+    validate(entity) {
+        if (entity.includes(':') ||
+            entity.includes('$') ||
+            entity.includes(' ')) {
+            throw "Invalid string [':','$',' ' not allowed]";
+        }
+    }
+    async getConnection() {
+        return await meshflow_1.MeshFlow.Connection.connect({
+            class: this.redisClass,
+            options: this.redisOptions,
+        });
+    }
+    getClient() {
+        return new meshflow_1.MeshFlow.Client({
+            connection: {
+                class: this.redisClass,
+                options: this.redisOptions,
+            }
+        });
+    }
+    safeKey(key) {
+        return `_${key}`;
+    }
+    arrayToHash(input) {
+        const [_count, ...rest] = input;
+        const max = rest.length / 2;
+        const hashes = [];
+        for (let i = 0; i < max * 2; i += 2) {
+            const fields = rest[i + 1];
+            const hash = { '$': rest[i] };
+            for (let j = 0; j < fields.length; j += 2) {
+                const fieldKey = fields[j].replace(/^_/, '');
+                const fieldValue = fields[j + 1];
+                hash[fieldKey] = fieldValue;
+            }
+            hashes.push(hash);
+        }
+        return hashes;
+    }
+    toString(value) {
+        switch (typeof value) {
+            case 'string':
+                break;
+            case 'boolean':
+                value = value ? '/t' : '/f';
+                break;
+            case 'number':
+                value = '/d' + value.toString();
+                break;
+            case 'undefined':
+                return undefined;
+            case 'object':
+                if (value === null) {
+                    value = '/n';
+                }
+                else {
+                    value = '/s' + JSON.stringify(value);
+                }
+                break;
+        }
+        return value;
+    }
+    static mintGuid(entity, id) {
+        if (!id && !entity) {
+            throw "Invalid arguments [entity and id are both null]";
+        }
+        else if (!id) {
+            id = hotmesh_1.HotMesh.guid();
+        }
+        else if (entity) {
+            entity = `${entity}-`;
+        }
+        else {
+            entity = '';
+        }
+        return `${entity}${id}`;
+    }
+    async getHotMesh(namespace = 'durable') {
+        let hotMesh = await this.instances.get(namespace);
+        if (!hotMesh) {
+            hotMesh = hotmesh_1.HotMesh.init({
+                appId: namespace,
+                engine: {
+                    redis: {
+                        class: this.redisClass,
+                        options: this.redisOptions,
+                    }
+                }
+            });
+            this.instances.set(namespace, hotMesh);
+            hotMesh = await hotMesh;
+            this.instances.set(namespace, hotMesh);
+        }
+        return hotMesh;
+    }
+    async mintKey(entity, workflowId, namespace) {
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, namespace);
+        const store = handle.hotMesh.engine?.store;
+        return store?.mintKey(hotmesh_2.KeyType.JOB_STATE, { jobId: workflowId, appId: handle.hotMesh.engine?.appId });
+    }
+    async connect({ entity, target, options = {} }) {
+        this.validate(entity);
+        this.connectionSignatures[entity] = target.toString();
+        const targetFunction = { [entity]: async (...args) => {
+                const { callOptions } = this.bindCallOptions(args, options);
+                const result = await target.apply(target, args);
+                await this.pauseForTTL(result, callOptions);
+                return result;
+            } };
+        await meshflow_1.MeshFlow.Worker.create({
+            namespace: options.namespace,
+            options: options.options,
+            connection: await this.getConnection(),
+            taskQueue: options.taskQueue ?? entity,
+            workflow: targetFunction,
+            search: options.search,
+        });
+        return true;
+    }
+    bindCallOptions(args, options, callOptions = {}) {
+        if (args.length) {
+            const lastArg = args[args.length - 1];
+            if (lastArg instanceof Object && lastArg?.$type === 'exec') {
+                callOptions = args.pop();
+                if (options.ttl === 'infinity') {
+                    if (!callOptions) {
+                        callOptions = { ttl: 'infinity' };
+                    }
+                    else {
+                        callOptions.ttl = 'infinity';
+                    }
+                }
+            }
+            else if (lastArg instanceof Object && lastArg.$type === 'hook') {
+                callOptions = args.pop();
+                delete callOptions.ttl;
+            }
+        }
+        return { callOptions };
+    }
+    async pauseForTTL(result, options) {
+        if (options?.ttl && options.$type === 'exec') {
+            const { counter, replay, workflowDimension, workflowId } = MeshData.workflow.getContext();
+            const prefix = options.ttl === 'infinity' ? 'wait' : 'sleep';
+            if (`-${prefix}${workflowDimension}-${counter + 1}-` in replay) {
+                return;
+            }
+            await new Promise(resolve => setImmediate(resolve));
+            options.$guid = options.$guid ?? workflowId;
+            const hotMesh = await MeshData.workflow.getHotMesh();
+            const store = hotMesh.engine?.store;
+            const jobKey = store?.mintKey(hotmesh_2.KeyType.JOB_STATE, { jobId: options.$guid, appId: hotMesh.engine?.appId });
+            const jobResponse = ['aAa', '/t', 'aBa', this.toString(result)];
+            await store?.exec('HSET', jobKey, ...jobResponse);
+            await this.publishDone(result, hotMesh, options);
+            if (options.ttl === 'infinity') {
+                await MeshData.workflow.waitFor(`flush-${options.$guid}`);
+            }
+            else {
+                await MeshData.workflow.sleepFor(options.ttl);
+            }
+        }
+    }
+    async publishDone(result, hotMesh, options) {
+        await hotMesh.engine?.store?.publish(hotmesh_2.KeyType.QUORUM, {
+            type: 'job',
+            topic: `${hotMesh.engine.appId}.executed`,
+            job: {
+                metadata: {
+                    tpc: `${hotMesh.engine.appId}.execute`,
+                    app: hotMesh.engine.appId,
+                    vrs: '1',
+                    jid: options.$guid,
+                    aid: 't1',
+                    ts: '0',
+                    js: 0
+                },
+                data: {
+                    done: true,
+                    response: result,
+                    workflowId: options.$guid
+                }
+            }
+        }, hotMesh.engine.appId, `${hotMesh.engine.appId}.executed.${options.$guid}`);
+    }
+    async flush(entity, id, namespace) {
+        const workflowId = MeshData.mintGuid(entity, id);
+        await this.getClient().workflow.signal(`flush-${workflowId}`, {}, namespace);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await this.interrupt(entity, id, {
+            descend: true,
+            suppress: true,
+            expire: 1
+        }, namespace);
+    }
+    async interrupt(entity, id, options = {}, namespace) {
+        const workflowId = MeshData.mintGuid(entity, id);
+        try {
+            const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, namespace);
+            const hotMesh = handle.hotMesh;
+            await hotMesh.interrupt(`${hotMesh.appId}.execute`, workflowId, options);
+        }
+        catch (e) {
+        }
+    }
+    async signal(guid, payload, namespace) {
+        return await this.getClient().workflow.signal(guid, payload, namespace);
+    }
+    async rollCall(options = {}) {
+        return (await this.getHotMesh(options.namespace || 'durable')).rollCall(options.delay || 1000);
+    }
+    async throttle(options) {
+        return (await this.getHotMesh(options.namespace || 'durable')).throttle(options);
+    }
+    async hook({ entity, id, hookEntity, hookArgs, options = {} }) {
+        const workflowId = MeshData.mintGuid(entity, id);
+        this.validate(workflowId);
+        return await this.getClient().workflow.hook({
+            namespace: options.namespace,
+            args: [...hookArgs, { ...options, $guid: workflowId, $type: 'hook' }],
+            taskQueue: options.taskQueue ?? hookEntity,
+            workflowName: hookEntity,
+            workflowId: options.workflowId ?? workflowId,
+            config: options.config ?? undefined,
+        });
+    }
+    async exec({ entity, args = [], options = {} }) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, options.id);
+        this.validate(workflowId);
+        const client = this.getClient();
+        try {
+            const handle = await client.workflow.getHandle(entity, entity, workflowId, options.namespace);
+            const state = await handle.hotMesh.getState(`${handle.hotMesh.appId}.execute`, handle.workflowId);
+            if (state?.data?.done) {
+                return state.data.response;
+            }
+            return await handle.result();
+        }
+        catch (e) {
+            const optionsClone = { ...options };
+            delete optionsClone.search;
+            delete optionsClone.config;
+            const handle = await client.workflow.start({
+                args: [...args, { ...optionsClone, $guid: workflowId, $type: 'exec' }],
+                taskQueue: options.taskQueue ?? entity,
+                workflowName: entity,
+                workflowId: options.workflowId ?? workflowId,
+                config: options.config ?? undefined,
+                search: options.search,
+                workflowTrace: options.workflowTrace,
+                workflowSpan: options.workflowSpan,
+                namespace: options.namespace,
+                await: options.await,
+                marker: options.marker,
+                pending: options.pending,
+                expire: options.expire,
+                signalIn: options.signalIn,
+            });
+            if (options.await === false) {
+                return handle.workflowId;
+            }
+            return await handle.result();
+        }
+    }
+    async info(entity, id, options = {}) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        const handle = await this.getClient().workflow.getHandle(options.taskQueue ?? entity, entity, workflowId, options.namespace);
+        return await handle.hotMesh.getState(`${handle.hotMesh.appId}.execute`, handle.workflowId);
+    }
+    async export(entity, id, options, namespace) {
+        const workflowId = MeshData.mintGuid(entity, id);
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, namespace);
+        return await handle.export(options);
+    }
+    async get(entity, id, options = {}) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        let prefixedFields = [];
+        if (Array.isArray(options.fields)) {
+            prefixedFields = options.fields.map(field => `_${field}`);
+        }
+        else if (this.search?.schema) {
+            prefixedFields = Object.entries(this.search.schema).map(([key, value]) => {
+                return 'fieldName' in value ? value.fieldName.toString() : `_${key}`;
+            });
+        }
+        else {
+            return await this.all(entity, id, options);
+        }
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
+        const store = handle.hotMesh.engine?.store;
+        const jobKey = await this.mintKey(entity, workflowId, options.namespace);
+        const vals = await store?.exec('HMGET', jobKey, ...prefixedFields);
+        const result = prefixedFields.reduce((obj, field, index) => {
+            obj[field.substring(1)] = vals?.[index];
+            return obj;
+        }, {});
+        return result;
+    }
+    async all(entity, id, options = {}) {
+        const rawResponse = await this.raw(entity, id, options);
+        const responseObj = {};
+        for (let key in rawResponse) {
+            if (key.startsWith('_')) {
+                responseObj[key.substring(1)] = rawResponse[key];
+            }
+        }
+        return responseObj;
+    }
+    async raw(entity, id, options = {}) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
+        const store = handle.hotMesh.engine?.store;
+        const jobKey = await this.mintKey(entity, workflowId, options.namespace);
+        const rawResponse = await store?.exec('HGETALL', jobKey);
+        const responseObj = {};
+        for (let i = 0; i < rawResponse.length; i += 2) {
+            responseObj[rawResponse[i]] = rawResponse[i + 1];
+        }
+        return responseObj;
+    }
+    async set(entity, id, options = {}) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
+        const store = handle.hotMesh.engine?.store;
+        const jobId = await this.mintKey(entity, workflowId, options.namespace);
+        const safeArgs = [];
+        for (let key in options.search?.data) {
+            safeArgs.push(this.safeKey(key), options.search?.data[key].toString());
+        }
+        return await store?.exec('HSET', jobId, ...safeArgs);
+    }
+    async incr(entity, id, field, amount, options = {}) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
+        const store = handle.hotMesh.engine?.store;
+        const jobId = await this.mintKey(entity, workflowId, options.namespace);
+        const result = await store?.exec('HINCRBYFLOAT', jobId, this.safeKey(field), amount.toString());
+        return Number(result);
+    }
+    async del(entity, id, options) {
+        const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
+        this.validate(workflowId);
+        if (!Array.isArray(options.fields)) {
+            throw "Invalid arguments [options.fields is not an array]";
+        }
+        const prefixedFields = options.fields.map(field => `_${field}`);
+        const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
+        const store = handle.hotMesh.engine?.store;
+        const jobKey = await this.mintKey(entity, workflowId, options.namespace);
+        const count = await store?.exec('HDEL', jobKey, ...prefixedFields);
+        return Number(count);
+    }
+    async findJobs(options = {}) {
+        const hotMesh = await this.getHotMesh(options.namespace);
+        return await hotMesh.engine?.store?.findJobs(options.match, options.limit, options.batch, options.cursor);
+    }
+    async find(entity, options, ...args) {
+        return await this.getClient().workflow.search(options.taskQueue ?? entity, options.workflowName ?? entity, options.namespace || 'durable', options.index ?? options.search?.index ?? this.search.index ?? '', ...args);
+    }
+    async findWhere(entity, options) {
+        const targetSearch = options.options?.search ?? this.search;
+        const args = [this.generateSearchQuery(options.query, targetSearch)];
+        if (options.count) {
+            args.push('LIMIT', '0', '0');
+        }
+        else {
+            args.push('RETURN');
+            args.push(((options.return?.length ?? 0) + 1).toString());
+            args.push('$');
+            options.return?.forEach(returnField => {
+                if (returnField.startsWith('"')) {
+                    args.push(returnField.slice(1, -1));
+                }
+                else {
+                    args.push(`_${returnField}`);
+                }
+            });
+            if (options.limit) {
+                args.push('LIMIT', options.limit.start.toString(), options.limit.size.toString());
+            }
+        }
+        const FTResults = await this.find(entity, options.options ?? {}, ...args);
+        const count = FTResults[0];
+        const sargs = `FT.SEARCH ${options.options?.index ?? targetSearch?.index} ${args.join(' ')}`;
+        if (options.count) {
+            return !isNaN(count) || count > 0 ? count : 0;
+        }
+        else if (count === 0) {
+            return { count, query: sargs, data: [] };
+        }
+        const hashes = this.arrayToHash(FTResults);
+        return { count, query: sargs, data: hashes };
+    }
+    generateSearchQuery(query, search) {
+        if (!Array.isArray(query) || query.length === 0) {
+            return typeof (query) === 'string' ? query : '*';
+        }
+        let queryString = query.map(q => {
+            const { field, is, value, type } = q;
+            let prefixedFieldName;
+            if (search?.schema && field in search.schema) {
+                if ('fieldName' in search.schema[field]) {
+                    prefixedFieldName = `@${search.schema[field].fieldName}`;
+                }
+                else {
+                    prefixedFieldName = `@_${field}`;
+                }
+            }
+            else {
+                prefixedFieldName = `@${field}`;
+            }
+            const fieldType = search?.schema?.[field]?.type ?? type ?? 'TEXT';
+            switch (fieldType) {
+                case 'TAG':
+                    return `${prefixedFieldName}:{${value}}`;
+                case 'TEXT':
+                    return `${prefixedFieldName}:"${value}"`;
+                case 'NUMERIC':
+                    let range = '';
+                    if (is.startsWith('=')) {
+                        range = `[${value} ${value}]`;
+                    }
+                    else if (is.startsWith('<')) {
+                        range = `[-inf ${value}]`;
+                    }
+                    else if (is.startsWith('>')) {
+                        range = `[${value} +inf]`;
+                    }
+                    else if (is === '[]') {
+                        range = `[${value[0]} ${value[1]}]`;
+                    }
+                    return `${prefixedFieldName}:${range}`;
+                default:
+                    return '';
+            }
+        }).join(' ');
+        return queryString;
+    }
+    async createSearchIndex(entity, options = {}, searchOptions) {
+        const workflowTopic = `${options.taskQueue ?? entity}-${entity}`;
+        const hotMeshClient = await this.getClient().getHotMeshClient(workflowTopic, options.namespace);
+        return await meshflow_1.MeshFlow.Search.configureSearchIndex(hotMeshClient, searchOptions ?? this.search);
+    }
+    async listSearchIndexes() {
+        const hotMeshClient = await this.getHotMesh();
+        return await meshflow_1.MeshFlow.Search.listSearchIndexes(hotMeshClient);
+    }
+    static async shutdown() {
+        await meshflow_1.MeshFlow.shutdown();
+    }
+}
+exports.MeshData = MeshData;
+_a = MeshData;
+MeshData.workflow = {
+    sleep: meshflow_1.MeshFlow.workflow.sleepFor,
+    sleepFor: meshflow_1.MeshFlow.workflow.sleepFor,
+    signal: meshflow_1.MeshFlow.workflow.signal,
+    hook: meshflow_1.MeshFlow.workflow.hook,
+    waitForSignal: meshflow_1.MeshFlow.workflow.waitFor,
+    waitFor: meshflow_1.MeshFlow.workflow.waitFor,
+    getHotMesh: meshflow_1.MeshFlow.workflow.getHotMesh,
+    random: meshflow_1.MeshFlow.workflow.random,
+    search: meshflow_1.MeshFlow.workflow.search,
+    getContext: meshflow_1.MeshFlow.workflow.getContext,
+    once: meshflow_1.MeshFlow.workflow.once,
+    interrupt: async (entity, id, options = {}) => {
+        const jobId = MeshData.mintGuid(entity, id);
+        await meshflow_1.MeshFlow.workflow.interrupt(jobId, options);
+    },
+    execChild: async (options = {}) => {
+        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        return meshflow_1.MeshFlow.workflow.execChild(pluckOptions);
+    },
+    executeChild: async (options = {}) => {
+        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        return meshflow_1.MeshFlow.workflow.execChild(pluckOptions);
+    },
+    startChild: async (options = {}) => {
+        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        return meshflow_1.MeshFlow.workflow.startChild(pluckOptions);
+    },
+};
+MeshData.proxyActivities = meshflow_1.MeshFlow.workflow.proxyActivities;
+;

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

@@ -0,0 +1,18 @@
+import { HotMesh } from '../hotmesh';
+import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/meshflow';
+export declare class ClientService {
+    connection: Connection;
+    options: WorkflowOptions;
+    static topics: string[];
+    static instances: Map<string, HotMesh | Promise<HotMesh>>;
+    constructor(config: ClientConfig);
+    getHotMeshClient: (workflowTopic: string | null, namespace?: string) => Promise<HotMesh>;
+    static createStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
+    verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
+    search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
+    workflow: ClientWorkflow;
+    deployAndActivate(namespace?: string, version?: string): Promise<void>;
+    verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
+    activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
+    static shutdown(): Promise<void>;
+}

package/build/services/{durable → meshflow}/client.js

@@ -17,8 +17,6 @@ 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;
             const connectionNS = `${optionsHash}.${targetNS}`;
@@ -27,8 +25,7 @@ class ClientService {
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
                 return hotMeshClient;
             }
-            //create and cache an instance
-            const hotMeshClient = hotmesh_1.HotMeshService.init({
+            const hotMeshClient = hotmesh_1.HotMesh.init({
                 appId: targetNS,
                 logLevel: enums_1.HMSH_LOGLEVEL,
                 engine: {
@@ -42,11 +39,6 @@ class ClientService {
             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;
@@ -69,10 +61,8 @@ class ClientService {
                 const workflowName = options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
-                //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],
@@ -80,11 +70,11 @@ class ClientService {
                     expire: options.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS,
                     signalIn: options.signalIn,
                     parentWorkflowId: options.parentWorkflowId,
-                    workflowId: options.workflowId || hotmesh_1.HotMeshService.guid(),
+                    workflowId: options.workflowId || hotmesh_1.HotMesh.guid(),
                     workflowTopic: workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
-                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL) /
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_MESHFLOW_MAX_INTERVAL) /
                         1000,
                 };
                 const context = { metadata: { trc, spn }, data: {} };
@@ -95,35 +85,25 @@ class ClientService {
                 });
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
-            /**
-             * send a message to a running workflow that is paused and awaiting the signal
-             */
             signal: async (signalId, data, namespace) => {
                 const topic = `${namespace ?? factory_1.APP_ID}.wfs.signal`;
                 return await (await this.getHotMeshClient(topic, namespace)).hook(topic, { id: signalId, data });
             },
-            /**
-             * send a message to spawn an parallel in-process thread of execution
-             * with the same job state as the main thread but bound to a different
-             * handler function. All job state will be journaled to the same hash
-             * as is used by the main thread.
-             */
             hook: async (options) => {
                 const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
                 const payload = {
                     arguments: [...options.args],
                     id: options.workflowId,
                     workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
-                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL) /
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_MESHFLOW_MAX_INTERVAL) /
                         1000,
                 };
-                //seed search data if presentthe hook before entering
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
                 const msgId = await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
                 if (options.search?.data) {
-                    const searchSessionId = `-search-${hotmesh_1.HotMeshService.guid()}-0`;
+                    const searchSessionId = `-search-${hotmesh_1.HotMesh.guid()}-0`;
                     const search = new search_1.Search(options.workflowId, hotMeshClient, searchSessionId);
                     const entries = Object.entries(options.search.data).flat();
                     await search.set(...entries);
@@ -151,10 +131,6 @@ class ClientService {
         };
         this.connection = config.connection;
     }
-    /**
-     * Any point of presence can be used to deploy and activate the HotMesh
-     * distributed executable to the active quorum.
-     */
     async deployAndActivate(namespace = factory_1.APP_ID, version = factory_1.APP_VERSION) {
         if (isNaN(Number(version))) {
             throw new Error('Invalid version number');
@@ -208,12 +184,6 @@ class ClientService {
 _a = ClientService;
 ClientService.topics = [];
 ClientService.instances = new Map();
-/**
- * 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.
- */
 ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) => {
     const store = hotMeshClient.engine.store;
     const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
@@ -222,7 +192,6 @@ ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) =>
         await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
     }
     catch (err) {
-        //ignore if already exists
     }
 };
 exports.ClientService = ClientService;