@hotmeshio/hotmesh 0.3.28 → 0.3.29

package/build/services/meshflow/workflow/emit.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emit = void 0;
+const common_1 = require("./common");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+async function emit(events, config = { once: true }) {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (!config.once || await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'emit')) {
+        for (const [topic, message] of Object.entries(events)) {
+            await hotMeshClient.quorum.pub({ topic, message });
+        }
+    }
+    return true;
+}
+exports.emit = emit;

package/build/services/meshflow/workflow/enrich.d.ts

@@ -0,0 +1,2 @@
+import { StringStringType } from './common';
+export declare function enrich(fields: StringStringType): Promise<boolean>;

package/build/services/meshflow/workflow/enrich.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrich = void 0;
+const searchMethods_1 = require("./searchMethods");
+async function enrich(fields) {
+    const searchSession = await (0, searchMethods_1.search)();
+    await searchSession.set(fields);
+    return true;
+}
+exports.enrich = enrich;

package/build/services/meshflow/workflow/execChild.d.ts

@@ -0,0 +1,4 @@
+import { WorkflowOptions } from './common';
+export declare function execChild<T>(options: WorkflowOptions): Promise<T>;
+export declare const executeChild: typeof execChild;
+export declare function startChild(options: WorkflowOptions): Promise<string>;

package/build/services/meshflow/workflow/execChild.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startChild = exports.executeChild = exports.execChild = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const didRun_1 = require("./didRun");
+function getChildInterruptPayload(context, options, execIndex) {
+    const { workflowId, originJobId, workflowDimension, expire } = context;
+    let childJobId;
+    if (options.workflowId) {
+        childJobId = options.workflowId;
+    }
+    else if (options.entity) {
+        childJobId = `${options.entity}-${(0, common_1.guid)()}-${workflowDimension}-${execIndex}`;
+    }
+    else {
+        childJobId = `-${options.workflowName}-${(0, common_1.guid)()}-${workflowDimension}-${execIndex}`;
+    }
+    const parentWorkflowId = workflowId;
+    const taskQueueName = options.taskQueue ?? options.entity;
+    const workflowName = options.entity ?? options.workflowName;
+    const workflowTopic = `${taskQueueName}-${workflowName}`;
+    return {
+        arguments: [...(options.args || [])],
+        await: options?.await ?? true,
+        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_MESHFLOW_EXP_BACKOFF,
+        index: execIndex,
+        maximumAttempts: options?.config?.maximumAttempts ?? common_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+        maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MESHFLOW_MAX_INTERVAL),
+        originJobId: originJobId ?? workflowId,
+        expire: options.expire ?? expire,
+        persistent: options.persistent,
+        signalIn: options.signalIn,
+        parentWorkflowId,
+        workflowDimension: workflowDimension,
+        workflowId: childJobId,
+        workflowTopic,
+    };
+}
+async function execChild(options) {
+    const isStartChild = options.await === false;
+    const prefix = isStartChild ? 'start' : 'child';
+    const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)(prefix);
+    const context = (0, context_1.getContext)();
+    const { canRetry, interruptionRegistry } = context;
+    if (didRunAlready) {
+        if (result?.$error && (!result.$error.is_stream_error || !canRetry)) {
+            if (options?.config?.throwOnError !== false) {
+                const code = result.$error.code;
+                const message = result.$error.message;
+                const stack = result.$error.stack;
+                if (code === common_1.HMSH_CODE_MESHFLOW_FATAL) {
+                    throw new common_1.MeshFlowFatalError(message, stack);
+                }
+                else if (code === common_1.HMSH_CODE_MESHFLOW_MAXED) {
+                    throw new common_1.MeshFlowMaxedError(message, stack);
+                }
+                else if (code === common_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
+                    throw new common_1.MeshFlowTimeoutError(message, stack);
+                }
+                else {
+                    throw new common_1.MeshFlowRetryError(message, stack);
+                }
+            }
+            return result.$error;
+        }
+        else if (!result?.$error) {
+            return result.data;
+        }
+    }
+    const interruptionMessage = getChildInterruptPayload(context, options, execIndex);
+    interruptionRegistry.push({
+        code: common_1.HMSH_CODE_MESHFLOW_CHILD,
+        ...interruptionMessage,
+    });
+    await (0, common_1.sleepImmediate)();
+    throw new common_1.MeshFlowChildError(interruptionMessage);
+}
+exports.execChild = execChild;
+exports.executeChild = execChild;
+async function startChild(options) {
+    return execChild({ ...options, await: false });
+}
+exports.startChild = startChild;

package/build/services/meshflow/workflow/hook.d.ts

@@ -0,0 +1,2 @@
+import { HookOptions } from './common';
+export declare function hook(options: HookOptions): Promise<string>;

package/build/services/meshflow/workflow/hook.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hook = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+async function hook(options) {
+    const { workflowId, connection, namespace, workflowTopic } = (0, context_1.getContext)();
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'hook')) {
+        const targetWorkflowId = options.workflowId ?? workflowId;
+        let targetTopic;
+        if (options.entity || (options.taskQueue && options.workflowName)) {
+            targetTopic = `${options.taskQueue ?? options.entity}-${options.entity ?? options.workflowName}`;
+        }
+        else {
+            targetTopic = workflowTopic;
+        }
+        const payload = {
+            arguments: [...options.args],
+            id: targetWorkflowId,
+            workflowTopic: targetTopic,
+            backoffCoefficient: options.config?.backoffCoefficient || common_1.HMSH_MESHFLOW_EXP_BACKOFF,
+            maximumAttempts: options.config?.maximumAttempts || common_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+            maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MESHFLOW_MAX_INTERVAL),
+        };
+        return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, common_1.StreamStatus.PENDING, 202);
+    }
+}
+exports.hook = hook;

package/build/services/meshflow/workflow/index.d.ts

@@ -0,0 +1,39 @@
+import { getContext } from './context';
+import { didRun } from './didRun';
+import { isSideEffectAllowed } from './isSideEffectAllowed';
+import { trace } from './trace';
+import { enrich } from './enrich';
+import { emit } from './emit';
+import { execChild, startChild } from './execChild';
+import { proxyActivities } from './proxyActivities';
+import { search } from './searchMethods';
+import { random } from './random';
+import { signal } from './signal';
+import { hook } from './hook';
+import { interrupt } from './interrupt';
+import { all } from './all';
+import { sleepFor } from './sleepFor';
+import { waitFor } from './waitFor';
+import { HotMesh } from './common';
+export declare class WorkflowService {
+    private constructor();
+    static getContext: typeof getContext;
+    static didRun: typeof didRun;
+    static isSideEffectAllowed: typeof isSideEffectAllowed;
+    static trace: typeof trace;
+    static enrich: typeof enrich;
+    static emit: typeof emit;
+    static execChild: typeof execChild;
+    static executeChild: typeof execChild;
+    static startChild: typeof startChild;
+    static proxyActivities: typeof proxyActivities;
+    static search: typeof search;
+    static random: typeof random;
+    static signal: typeof signal;
+    static hook: typeof hook;
+    static interrupt: typeof interrupt;
+    static all: typeof all;
+    static sleepFor: typeof sleepFor;
+    static waitFor: typeof waitFor;
+    static getHotMesh(): Promise<HotMesh>;
+}

package/build/services/meshflow/workflow/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const context_1 = require("./context");
+const didRun_1 = require("./didRun");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+const trace_1 = require("./trace");
+const enrich_1 = require("./enrich");
+const emit_1 = require("./emit");
+const execChild_1 = require("./execChild");
+const proxyActivities_1 = require("./proxyActivities");
+const searchMethods_1 = require("./searchMethods");
+const random_1 = require("./random");
+const signal_1 = require("./signal");
+const hook_1 = require("./hook");
+const interrupt_1 = require("./interrupt");
+const all_1 = require("./all");
+const sleepFor_1 = require("./sleepFor");
+const waitFor_1 = require("./waitFor");
+const common_1 = require("./common");
+class WorkflowService {
+    constructor() { }
+    static async getHotMesh() {
+        const store = common_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
+        const namespace = store.get('namespace');
+        return await common_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
+            namespace,
+        });
+    }
+}
+WorkflowService.getContext = context_1.getContext;
+WorkflowService.didRun = didRun_1.didRun;
+WorkflowService.isSideEffectAllowed = isSideEffectAllowed_1.isSideEffectAllowed;
+WorkflowService.trace = trace_1.trace;
+WorkflowService.enrich = enrich_1.enrich;
+WorkflowService.emit = emit_1.emit;
+WorkflowService.execChild = execChild_1.execChild;
+WorkflowService.executeChild = execChild_1.executeChild;
+WorkflowService.startChild = execChild_1.startChild;
+WorkflowService.proxyActivities = proxyActivities_1.proxyActivities;
+WorkflowService.search = searchMethods_1.search;
+WorkflowService.random = random_1.random;
+WorkflowService.signal = signal_1.signal;
+WorkflowService.hook = hook_1.hook;
+WorkflowService.interrupt = interrupt_1.interrupt;
+WorkflowService.all = all_1.all;
+WorkflowService.sleepFor = sleepFor_1.sleepFor;
+WorkflowService.waitFor = waitFor_1.waitFor;
+exports.WorkflowService = WorkflowService;

package/build/services/meshflow/workflow/interrupt.d.ts

@@ -0,0 +1,2 @@
+import { JobInterruptOptions } from './common';
+export declare function interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;

package/build/services/meshflow/workflow/interrupt.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interrupt = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+async function interrupt(jobId, options = {}) {
+    const { workflowTopic, connection, namespace } = (0, context_1.getContext)();
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'interrupt')) {
+        return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
+    }
+}
+exports.interrupt = interrupt;

package/build/services/meshflow/workflow/isSideEffectAllowed.d.ts

@@ -0,0 +1,2 @@
+import { HotMesh } from './common';
+export declare function isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;

package/build/services/meshflow/workflow/isSideEffectAllowed.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSideEffectAllowed = void 0;
+const common_1 = require("./common");
+async function isSideEffectAllowed(hotMeshClient, prefix) {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+    const replay = store.get('replay');
+    if (sessionId in replay) {
+        return false;
+    }
+    const keyParams = {
+        appId: hotMeshClient.appId,
+        jobId: workflowId,
+    };
+    const workflowGuid = common_1.KeyService.mintKey(hotMeshClient.namespace, common_1.KeyType.JOB_STATE, keyParams);
+    const searchClient = hotMeshClient.engine.search;
+    const guidValue = await searchClient.incrementFieldByFloat(workflowGuid, sessionId, 1);
+    return guidValue === 1;
+}
+exports.isSideEffectAllowed = isSideEffectAllowed;

package/build/services/meshflow/workflow/proxyActivities.d.ts

@@ -0,0 +1,6 @@
+import { ActivityConfig, ProxyType, MeshFlowProxyErrorType } from './common';
+import { getContext } from './context';
+declare function getProxyInterruptPayload(context: ReturnType<typeof getContext>, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): MeshFlowProxyErrorType;
+declare function wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
+export declare function proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
+export { wrapActivity, getProxyInterruptPayload };

package/build/services/meshflow/workflow/proxyActivities.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxyInterruptPayload = exports.wrapActivity = exports.proxyActivities = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const didRun_1 = require("./didRun");
+function getProxyInterruptPayload(context, activityName, execIndex, args, options) {
+    const { workflowDimension, workflowId, originJobId, workflowTopic, expire, } = context;
+    const activityTopic = `${workflowTopic}-activity`;
+    const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
+    let maximumInterval;
+    if (options?.retryPolicy?.maximumInterval) {
+        maximumInterval = (0, common_1.s)(options.retryPolicy.maximumInterval);
+    }
+    return {
+        arguments: args,
+        workflowDimension,
+        index: execIndex,
+        originJobId: originJobId || workflowId,
+        parentWorkflowId: workflowId,
+        workflowId: activityJobId,
+        workflowTopic: activityTopic,
+        activityName,
+        expire: options?.expire ?? expire,
+        backoffCoefficient: options?.retryPolicy?.backoffCoefficient ?? undefined,
+        maximumAttempts: options?.retryPolicy?.maximumAttempts ?? undefined,
+        maximumInterval: maximumInterval ?? undefined,
+    };
+}
+exports.getProxyInterruptPayload = getProxyInterruptPayload;
+function wrapActivity(activityName, options) {
+    return (async function (...args) {
+        const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)('proxy');
+        if (didRunAlready) {
+            if (result?.$error) {
+                if (options?.retryPolicy?.throwOnError !== false) {
+                    const code = result.$error.code;
+                    const message = result.$error.message;
+                    const stack = result.$error.stack;
+                    if (code === common_1.HMSH_CODE_MESHFLOW_FATAL) {
+                        throw new common_1.MeshFlowFatalError(message, stack);
+                    }
+                    else if (code === common_1.HMSH_CODE_MESHFLOW_MAXED) {
+                        throw new common_1.MeshFlowMaxedError(message, stack);
+                    }
+                    else if (code === common_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
+                        throw new common_1.MeshFlowTimeoutError(message, stack);
+                    }
+                    else {
+                    }
+                }
+                return result.$error;
+            }
+            return result.data;
+        }
+        const context = (0, context_1.getContext)();
+        const { interruptionRegistry } = context;
+        const interruptionMessage = getProxyInterruptPayload(context, activityName, execIndex, args, options);
+        interruptionRegistry.push({
+            code: common_1.HMSH_CODE_MESHFLOW_PROXY,
+            ...interruptionMessage,
+        });
+        await (0, common_1.sleepImmediate)();
+        throw new common_1.MeshFlowProxyError(interruptionMessage);
+    });
+}
+exports.wrapActivity = wrapActivity;
+function proxyActivities(options) {
+    if (options?.activities) {
+        common_1.WorkerService.registerActivities(options.activities);
+    }
+    const proxy = {};
+    const keys = Object.keys(common_1.WorkerService.activityRegistry);
+    if (keys.length) {
+        keys.forEach((key) => {
+            const activityFunction = common_1.WorkerService.activityRegistry[key];
+            proxy[key] = wrapActivity(key, options);
+        });
+    }
+    return proxy;
+}
+exports.proxyActivities = proxyActivities;

package/build/services/meshflow/workflow/random.d.ts

@@ -0,0 +1 @@
+export declare function random(): number;

package/build/services/meshflow/workflow/random.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+const common_1 = require("./common");
+function random() {
+    const store = common_1.asyncLocalStorage.getStore();
+    const COUNTER = store.get('counter');
+    const seed = COUNTER.counter = COUNTER.counter + 1;
+    return (0, common_1.deterministicRandom)(seed);
+}
+exports.random = random;

package/build/services/meshflow/workflow/searchMethods.d.ts

@@ -0,0 +1,2 @@
+import { Search } from './common';
+export declare function search(): Promise<Search>;

package/build/services/meshflow/workflow/searchMethods.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = void 0;
+const common_1 = require("./common");
+async function search() {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    const searchSessionId = `-search${workflowDimension}-${execIndex}`;
+    return new common_1.Search(workflowId, hotMeshClient, searchSessionId);
+}
+exports.search = search;

package/build/services/meshflow/workflow/signal.d.ts

@@ -0,0 +1 @@
+export declare function signal(signalId: string, data: Record<any, any>): Promise<string>;

package/build/services/meshflow/workflow/signal.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signal = void 0;
+const common_1 = require("./common");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+async function signal(signalId, data) {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'signal')) {
+        return await hotMeshClient.hook(`${namespace}.wfs.signal`, {
+            id: signalId,
+            data,
+        });
+    }
+}
+exports.signal = signal;

package/build/services/meshflow/workflow/sleepFor.d.ts

@@ -0,0 +1 @@
+export declare function sleepFor(duration: string): Promise<number>;

package/build/services/meshflow/workflow/sleepFor.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleepFor = void 0;
+const common_1 = require("./common");
+const didRun_1 = require("./didRun");
+async function sleepFor(duration) {
+    const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)('sleep');
+    if (didRunAlready) {
+        return result.duration;
+    }
+    const store = common_1.asyncLocalStorage.getStore();
+    const interruptionRegistry = store.get('interruptionRegistry');
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const interruptionMessage = {
+        workflowId,
+        duration: (0, common_1.s)(duration),
+        index: execIndex,
+        workflowDimension,
+    };
+    interruptionRegistry.push({
+        code: common_1.HMSH_CODE_MESHFLOW_SLEEP,
+        ...interruptionMessage,
+    });
+    await (0, common_1.sleepImmediate)();
+    throw new common_1.MeshFlowSleepError(interruptionMessage);
+}
+exports.sleepFor = sleepFor;

package/build/services/meshflow/workflow/trace.d.ts

@@ -0,0 +1,4 @@
+import { StringScalarType } from './common';
+export declare function trace(attributes: StringScalarType, config?: {
+    once: boolean;
+}): Promise<boolean>;

package/build/services/meshflow/workflow/trace.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+async function trace(attributes, config = { once: true }) {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    const { raw, COUNTER } = (0, context_1.getContext)();
+    const { trc: traceId, spn: spanId, aid: activityId } = raw.metadata;
+    if (!config.once || await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'trace')) {
+        return await common_1.TelemetryService.traceActivity(namespace, attributes, activityId, traceId, spanId, COUNTER.counter);
+    }
+    return true;
+}
+exports.trace = trace;

package/build/services/meshflow/workflow/waitFor.d.ts

@@ -0,0 +1 @@
+export declare function waitFor<T>(signalId: string): Promise<T>;

package/build/services/meshflow/workflow/waitFor.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = void 0;
+const common_1 = require("./common");
+const didRun_1 = require("./didRun");
+async function waitFor(signalId) {
+    const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)('wait');
+    if (didRunAlready) {
+        return result.data.data;
+    }
+    const store = common_1.asyncLocalStorage.getStore();
+    const interruptionRegistry = store.get('interruptionRegistry');
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const interruptionMessage = {
+        workflowId,
+        signalId,
+        index: execIndex,
+        workflowDimension,
+    };
+    interruptionRegistry.push({
+        code: common_1.HMSH_CODE_MESHFLOW_WAIT,
+        ...interruptionMessage,
+    });
+    await (0, common_1.sleepImmediate)();
+    throw new common_1.MeshFlowWaitForError(interruptionMessage);
+}
+exports.waitFor = waitFor;

package/build/services/meshos/index.d.ts

@@ -5,7 +5,9 @@ declare abstract class MeshOS {
     meshData: MeshData;
     connected: boolean;
     namespace: string;
-    namespaceType: string;
+    schema: Types.WorkflowSearchSchema;
+    entity: string;
+    taskQueue: string;
     static databases: Record<string, Types.DB>;
     static namespaces: Types.Namespaces;
     static entities: Record<string, Types.Entity>;
@@ -13,13 +15,14 @@ declare abstract class MeshOS {
     static profiles: Types.Profiles;
     static classes: Record<string, typeof MeshOS>;
     static logger: Types.ILogger;
-    constructor(providerConfig: ProviderConfig | ProvidersConfig, namespace: string, namespaceType: string);
-    protected abstract getEntity(): string;
-    abstract getSearchOptions(): Types.WorkflowSearchOptions;
-    protected abstract getTaskQueue(): string;
+    constructor(providerConfig: ProviderConfig | ProvidersConfig, namespace: string, entity?: string, taskQueue?: string, schema?: Types.WorkflowSearchSchema);
+    getEntity(): string;
+    getSearchOptions(): Types.WorkflowSearchOptions;
+    getTaskQueue(): string;
     private initializeMeshData;
     protected defaultTargetFn(): Promise<string>;
     getNamespace(): string;
+    getSchema(): Types.WorkflowSearchSchema;
     connect(): Promise<void>;
     index(): Promise<void>;
     static shutdown(): Promise<void>;