@hotmeshio/hotmesh 0.3.32 → 0.4.0

package/build/services/meshflow/worker.js

@@ -1,514 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerService = void 0;
-const enums_1 = require("../../modules/enums");
-const errors_1 = require("../../modules/errors");
-const storage_1 = require("../../modules/storage");
-const utils_1 = require("../../modules/utils");
-const hotmesh_1 = require("../hotmesh");
-const stream_1 = require("../../types/stream");
-const search_1 = require("./search");
-const factory_1 = require("./schemas/factory");
-/**
- * The *Worker* service Registers worker functions and connects them to the mesh,
- * using the target backend provider/s (Redis, Postgres, NATS, etc).
- *
- * @example
- * ```typescript
- * import { MeshFlow } from '@hotmeshio/hotmesh';
- * import { Client as Postgres } from 'pg';
- * import * as workflows from './workflows';
- *
- * async function run() {
- *   const worker = await MeshFlow.Worker.create({
- *     connection: {
- *       class: Postgres,
- *       options: { connectionString: 'postgres://user:password@localhost:5432/db' }
- *     },
- *     taskQueue: 'default',
- *     workflow: workflows.example,
- *   });
- *
- *   await worker.run();
- * }
- * ```
- */
-class WorkerService {
-    static hashOptions(connection) {
-        if ('options' in connection) {
-            //shorthand format
-            return (0, utils_1.hashOptions)(connection.options);
-        }
-        else {
-            //longhand format (sub, store, stream, pub, search)
-            const response = [];
-            for (const p in connection) {
-                if (connection[p].options) {
-                    response.push((0, utils_1.hashOptions)(connection[p].options));
-                }
-            }
-            return response.join('');
-        }
-    }
-    /**
-     * @private
-     */
-    constructor() { }
-    /**
-     * @private
-     */
-    static async activateWorkflow(hotMesh) {
-        const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
-        const appVersion = app?.version;
-        if (!appVersion) {
-            try {
-                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(hotMesh.engine.appId, factory_1.APP_VERSION));
-                await hotMesh.activate(factory_1.APP_VERSION);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('meshflow-worker-deploy-activate-err', err);
-                throw err;
-            }
-        }
-        else if (app && !app.active) {
-            try {
-                await hotMesh.activate(factory_1.APP_VERSION);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('meshflow-worker-activate-err', err);
-                throw err;
-            }
-        }
-    }
-    /**
-     * @private
-     */
-    static registerActivities(activities) {
-        if (typeof activities === 'function' &&
-            typeof WorkerService.activityRegistry[activities.name] !== 'function') {
-            WorkerService.activityRegistry[activities.name] = activities;
-        }
-        else {
-            Object.keys(activities).forEach((key) => {
-                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;
-    }
-    /**
-     * Connects a worker to the mesh.
-     *
-     * @example
-     * ```typescript
-     * import { MeshFlow } from '@hotmeshio/hotmesh';
-     * import { Client as Postgres } from 'pg';
-     * import * as workflows from './workflows';
-     *
-     * async function run() {
-     *   const worker = await MeshFlow.Worker.create({
-     *     connection: {
-     *       class: Postgres,
-     *       options: {
-     *         connectionString: 'postgres://user:password@localhost:5432/db'
-     *       },
-     *     },
-     *     taskQueue: 'default',
-     *     workflow: workflows.example,
-     *   });
-     *
-     *   await worker.run();
-     * }
-     * ```
-     */
-    static async create(config) {
-        const workflow = config.workflow;
-        const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
-        const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
-        const activityTopic = `${baseTopic}-activity`;
-        const workflowTopic = `${baseTopic}`;
-        //initialize supporting workflows
-        const worker = new WorkerService();
-        worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
-        worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
-        search_1.Search.configureSearchIndex(worker.workflowRunner, config.search);
-        await WorkerService.activateWorkflow(worker.workflowRunner);
-        return worker;
-    }
-    /**
-     * @private
-     */
-    static resolveWorkflowTarget(workflow, name) {
-        let workflowFunction;
-        if (typeof workflow === 'function') {
-            workflowFunction = workflow;
-            return [workflowFunction.name ?? name, workflowFunction];
-        }
-        else {
-            const workflowFunctionNames = Object.keys(workflow);
-            const lastFunctionName = workflowFunctionNames[workflowFunctionNames.length - 1];
-            workflowFunction = workflow[lastFunctionName];
-            return WorkerService.resolveWorkflowTarget(workflowFunction, lastFunctionName);
-        }
-    }
-    /**
-     * Run the connected worker; no-op (unnecessary to call)
-     */
-    async run() {
-        this.workflowRunner.engine.logger.info('meshflow-worker-running');
-    }
-    /**
-     * @private
-     */
-    async initActivityWorker(config, activityTopic) {
-        const providerConfig = config.connection;
-        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
-        const optionsHash = WorkerService.hashOptions(config?.connection);
-        const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
-        const hotMeshWorker = await hotmesh_1.HotMesh.init({
-            guid: config.guid ? `${config.guid}XA` : undefined,
-            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-            appId: targetNamespace,
-            engine: { connection: providerConfig },
-            workers: [
-                {
-                    topic: activityTopic,
-                    connection: providerConfig,
-                    callback: this.wrapActivityFunctions().bind(this),
-                },
-            ],
-        });
-        WorkerService.instances.set(targetTopic, hotMeshWorker);
-        return hotMeshWorker;
-    }
-    /**
-     * @private
-     */
-    wrapActivityFunctions() {
-        return async (data) => {
-            try {
-                //always run the activity function when instructed; return the response
-                const activityInput = data.data;
-                const activityName = activityInput.activityName;
-                const activityFunction = WorkerService.activityRegistry[activityName];
-                const pojoResponse = await activityFunction.apply(this, activityInput.arguments);
-                return {
-                    status: stream_1.StreamStatus.SUCCESS,
-                    metadata: { ...data.metadata },
-                    data: { response: pojoResponse },
-                };
-            }
-            catch (err) {
-                this.activityRunner.engine.logger.error('meshflow-worker-activity-err', {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack,
-                });
-                if (!(err instanceof errors_1.MeshFlowTimeoutError) &&
-                    !(err instanceof errors_1.MeshFlowMaxedError) &&
-                    !(err instanceof errors_1.MeshFlowFatalError)) {
-                    //use code 599 as a proxy for all retryable errors
-                    // (basically anything not 596, 597, 598)
-                    return {
-                        status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_MESHFLOW_RETRYABLE,
-                        metadata: { ...data.metadata },
-                        data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                timestamp: (0, utils_1.formatISODate)(new Date()),
-                            },
-                        },
-                    };
-                }
-                return {
-                    //always returrn success (the MeshFlow module is just fine);
-                    //  it's the user's function that has failed
-                    status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code,
-                    stack: err.stack,
-                    metadata: { ...data.metadata },
-                    data: {
-                        $error: {
-                            message: err.message,
-                            stack: err.stack,
-                            timestamp: (0, utils_1.formatISODate)(new Date()),
-                            code: err.code,
-                        },
-                    },
-                };
-            }
-        };
-    }
-    /**
-     * @private
-     */
-    async initWorkflowWorker(config, workflowTopic, workflowFunction) {
-        const providerConfig = config.connection;
-        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
-        const optionsHash = WorkerService.hashOptions(config?.connection);
-        const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
-        const hotMeshWorker = await hotmesh_1.HotMesh.init({
-            guid: config.guid,
-            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-            appId: config.namespace ?? factory_1.APP_ID,
-            engine: { connection: providerConfig },
-            workers: [
-                {
-                    topic: workflowTopic,
-                    connection: providerConfig,
-                    callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic, config).bind(this),
-                },
-            ],
-        });
-        WorkerService.instances.set(targetTopic, hotMeshWorker);
-        return hotMeshWorker;
-    }
-    /**
-     * @private
-     */
-    wrapWorkflowFunction(workflowFunction, workflowTopic, config) {
-        return async (data) => {
-            const counter = { counter: 0 };
-            const interruptionRegistry = [];
-            let isProcessing = false;
-            try {
-                //incoming data payload has arguments and workflowId
-                const workflowInput = data.data;
-                const context = new Map();
-                context.set('canRetry', workflowInput.canRetry);
-                context.set('expire', workflowInput.expire);
-                context.set('counter', counter);
-                context.set('interruptionRegistry', interruptionRegistry);
-                context.set('connection', config.connection);
-                context.set('namespace', config.namespace ?? factory_1.APP_ID);
-                context.set('raw', data);
-                context.set('workflowId', workflowInput.workflowId);
-                if (workflowInput.originJobId) {
-                    //if present there is an origin job to which this job is subordinated;
-                    // garbage collect (expire) this job when originJobId is expired
-                    context.set('originJobId', workflowInput.originJobId);
-                }
-                //TODO: the query is provider-specific;
-                //      refactor as an abstract interface the provider must implement
-                let replayQuery = '';
-                if (workflowInput.workflowDimension) {
-                    //every hook function runs in an isolated dimension controlled
-                    //by the index assigned when the signal was received; even if the
-                    //hook function re-runs, its scope will always remain constant
-                    context.set('workflowDimension', workflowInput.workflowDimension);
-                    replayQuery = `-*${workflowInput.workflowDimension}-*`;
-                }
-                else {
-                    //last letter of words like 'hook', 'sleep', 'wait', 'signal', 'search', 'start', 'proxy', 'child', 'collator', 'trace', 'enrich', 'publish'
-                    replayQuery = '-*[ehklptydr]-*';
-                }
-                context.set('workflowTopic', workflowTopic);
-                context.set('workflowName', workflowTopic.split('-').pop());
-                context.set('workflowTrace', data.metadata.trc);
-                context.set('workflowSpan', data.metadata.spn);
-                const store = this.workflowRunner.engine.store;
-                const [cursor, replay] = await store.findJobFields(workflowInput.workflowId, replayQuery, 50000, 5000);
-                context.set('replay', replay);
-                context.set('cursor', cursor); // if != 0, more remain
-                const workflowResponse = await storage_1.asyncLocalStorage.run(context, async () => {
-                    return await workflowFunction.apply(this, workflowInput.arguments);
-                });
-                return {
-                    code: 200,
-                    status: stream_1.StreamStatus.SUCCESS,
-                    metadata: { ...data.metadata },
-                    data: { response: workflowResponse, done: true },
-                };
-            }
-            catch (err) {
-                if (isProcessing) {
-                    return;
-                }
-                if (err instanceof errors_1.MeshFlowWaitForError ||
-                    interruptionRegistry.length > 1) {
-                    isProcessing = true;
-                    //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
-                    const workflowInput = data.data;
-                    const execIndex = counter.counter - interruptionRegistry.length + 1;
-                    const { workflowId, workflowTopic, workflowDimension, originJobId, expire, } = workflowInput;
-                    const collatorFlowId = `${(0, utils_1.guid)()}$C`;
-                    return {
-                        status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_MESHFLOW_ALL,
-                        metadata: { ...data.metadata },
-                        data: {
-                            code: enums_1.HMSH_CODE_MESHFLOW_ALL,
-                            items: [...interruptionRegistry],
-                            size: interruptionRegistry.length,
-                            workflowDimension: workflowDimension || '',
-                            index: execIndex,
-                            originJobId: originJobId || workflowId,
-                            parentWorkflowId: workflowId,
-                            workflowId: collatorFlowId,
-                            workflowTopic: workflowTopic,
-                            expire,
-                        },
-                    };
-                }
-                else if (err instanceof errors_1.MeshFlowSleepError) {
-                    //return the sleep interruption
-                    isProcessing = true;
-                    return {
-                        status: stream_1.StreamStatus.SUCCESS,
-                        code: err.code,
-                        metadata: { ...data.metadata },
-                        data: {
-                            code: err.code,
-                            message: JSON.stringify({
-                                duration: err.duration,
-                                index: err.index,
-                                workflowDimension: err.workflowDimension,
-                            }),
-                            duration: err.duration,
-                            index: err.index,
-                            workflowDimension: err.workflowDimension,
-                        },
-                    };
-                }
-                else if (err instanceof errors_1.MeshFlowProxyError) {
-                    //return the proxyActivity interruption
-                    isProcessing = true;
-                    return {
-                        status: stream_1.StreamStatus.SUCCESS,
-                        code: err.code,
-                        metadata: { ...data.metadata },
-                        data: {
-                            code: err.code,
-                            message: JSON.stringify({
-                                message: err.message,
-                                workflowId: err.workflowId,
-                                activityName: err.activityName,
-                                dimension: err.workflowDimension,
-                            }),
-                            arguments: err.arguments,
-                            workflowDimension: err.workflowDimension,
-                            index: err.index,
-                            originJobId: err.originJobId,
-                            parentWorkflowId: err.parentWorkflowId,
-                            expire: err.expire,
-                            workflowId: err.workflowId,
-                            workflowTopic: err.workflowTopic,
-                            activityName: err.activityName,
-                            backoffCoefficient: err.backoffCoefficient,
-                            maximumAttempts: err.maximumAttempts,
-                            maximumInterval: err.maximumInterval,
-                        },
-                    };
-                }
-                else if (err instanceof errors_1.MeshFlowChildError) {
-                    //return the child interruption
-                    isProcessing = true;
-                    const msg = {
-                        message: err.message,
-                        workflowId: err.workflowId,
-                        dimension: err.workflowDimension,
-                    };
-                    return {
-                        status: stream_1.StreamStatus.SUCCESS,
-                        code: err.code,
-                        metadata: { ...data.metadata },
-                        data: {
-                            arguments: err.arguments,
-                            await: err.await,
-                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
-                            code: err.code,
-                            index: err.index,
-                            message: JSON.stringify(msg),
-                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
-                            maximumInterval: err.maximumInterval || (0, utils_1.s)(enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
-                            originJobId: err.originJobId,
-                            parentWorkflowId: err.parentWorkflowId,
-                            expire: err.expire,
-                            persistent: err.persistent,
-                            signalIn: err.signalIn,
-                            workflowDimension: err.workflowDimension,
-                            workflowId: err.workflowId,
-                            workflowTopic: err.workflowTopic,
-                        },
-                    };
-                }
-                // ALL other errors are actual fatal errors (598, 597, 596)
-                //  OR will be retried (599)
-                isProcessing = true;
-                return {
-                    status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
-                    metadata: { ...data.metadata },
-                    data: {
-                        $error: {
-                            message: err.message,
-                            type: err.name,
-                            name: err.name,
-                            stack: err.stack,
-                            code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
-                        },
-                    },
-                };
-            }
-        };
-    }
-    /**
-     * @private
-     */
-    static async shutdown() {
-        for (const [_, hotMeshInstance] of WorkerService.instances) {
-            (await hotMeshInstance).stop();
-        }
-    }
-}
-_a = WorkerService;
-/**
- * @private
- */
-WorkerService.activityRegistry = {}; //user's activities
-/**
- * @private
- */
-WorkerService.instances = new Map();
-/**
- * @private
- */
-WorkerService.getHotMesh = async (workflowTopic, config, options) => {
-    const targetNamespace = config?.namespace ?? factory_1.APP_ID;
-    const optionsHash = WorkerService.hashOptions(config?.connection);
-    const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
-    if (WorkerService.instances.has(targetTopic)) {
-        return await WorkerService.instances.get(targetTopic);
-    }
-    const hotMeshClient = hotmesh_1.HotMesh.init({
-        logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-        appId: targetNamespace,
-        engine: {
-            connection: { ...config?.connection },
-        },
-    });
-    WorkerService.instances.set(targetTopic, hotMeshClient);
-    await WorkerService.activateWorkflow(await hotMeshClient);
-    return hotMeshClient;
-};
-/**
- * @private
- */
-WorkerService.Context = {
-    info: () => {
-        return {
-            workflowId: '',
-            workflowTopic: '',
-        };
-    },
-};
-exports.WorkerService = WorkerService;

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

@@ -1,7 +0,0 @@
-/**
- * A workflow-safe version of Promise.all, currently limited to certain concurrency.
- * @private
- * @param {...Promise<T>[]} promises - An array of promises.
- * @returns {Promise<T[]>} A promise resolving to an array of results.
- */
-export declare function all<T>(...promises: Promise<T>[]): Promise<T[]>;

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.all = void 0;
-/**
- * A workflow-safe version of Promise.all, currently limited to certain concurrency.
- * @private
- * @param {...Promise<T>[]} promises - An array of promises.
- * @returns {Promise<T[]>} A promise resolving to an array of results.
- */
-async function all(...promises) {
-    // a micro-delay to ensure correct sequencing
-    await new Promise((resolve) => setTimeout(resolve, 1));
-    return await Promise.all(promises);
-}
-exports.all = all;

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

@@ -1,18 +0,0 @@
-import { MeshFlowChildError, MeshFlowFatalError, MeshFlowMaxedError, MeshFlowProxyError, MeshFlowRetryError, MeshFlowSleepError, MeshFlowTimeoutError, MeshFlowWaitForError } from '../../../modules/errors';
-import { KeyService, KeyType } from '../../../modules/key';
-import { asyncLocalStorage } from '../../../modules/storage';
-import { deterministicRandom, guid, s, sleepImmediate } from '../../../modules/utils';
-import { HotMesh } from '../../hotmesh';
-import { SerializerService } from '../../serializer';
-import { ActivityConfig, ChildResponseType, HookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions } from '../../../types/meshflow';
-import { JobInterruptOptions } from '../../../types/job';
-import { StreamCode, StreamStatus } from '../../../types/stream';
-import { StringAnyType, StringScalarType, StringStringType } from '../../../types/serializer';
-import { HMSH_CODE_MESHFLOW_CHILD, HMSH_CODE_MESHFLOW_FATAL, HMSH_CODE_MESHFLOW_MAXED, HMSH_CODE_MESHFLOW_PROXY, HMSH_CODE_MESHFLOW_SLEEP, HMSH_CODE_MESHFLOW_TIMEOUT, HMSH_CODE_MESHFLOW_WAIT, HMSH_MESHFLOW_EXP_BACKOFF, HMSH_MESHFLOW_MAX_ATTEMPTS, HMSH_MESHFLOW_MAX_INTERVAL } from '../../../modules/enums';
-import { MeshFlowChildErrorType, MeshFlowProxyErrorType } from '../../../types/error';
-import { TelemetryService } from '../../telemetry';
-import { QuorumMessage } from '../../../types';
-import { UserMessage } from '../../../types/quorum';
-import { Search } from '../search';
-import { WorkerService } from '../worker';
-export { MeshFlowChildError, MeshFlowFatalError, MeshFlowMaxedError, MeshFlowProxyError, MeshFlowRetryError, MeshFlowSleepError, MeshFlowTimeoutError, MeshFlowWaitForError, KeyService, KeyType, asyncLocalStorage, deterministicRandom, guid, s, sleepImmediate, HotMesh, SerializerService, ActivityConfig, ChildResponseType, HookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions, JobInterruptOptions, StreamCode, StreamStatus, StringAnyType, StringScalarType, StringStringType, HMSH_CODE_MESHFLOW_CHILD, HMSH_CODE_MESHFLOW_FATAL, HMSH_CODE_MESHFLOW_MAXED, HMSH_CODE_MESHFLOW_PROXY, HMSH_CODE_MESHFLOW_SLEEP, HMSH_CODE_MESHFLOW_TIMEOUT, HMSH_CODE_MESHFLOW_WAIT, HMSH_MESHFLOW_EXP_BACKOFF, HMSH_MESHFLOW_MAX_ATTEMPTS, HMSH_MESHFLOW_MAX_INTERVAL, MeshFlowChildErrorType, MeshFlowProxyErrorType, TelemetryService, QuorumMessage, UserMessage, Search, WorkerService, };

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerService = exports.Search = exports.TelemetryService = exports.HMSH_MESHFLOW_MAX_INTERVAL = exports.HMSH_MESHFLOW_MAX_ATTEMPTS = exports.HMSH_MESHFLOW_EXP_BACKOFF = exports.HMSH_CODE_MESHFLOW_WAIT = exports.HMSH_CODE_MESHFLOW_TIMEOUT = exports.HMSH_CODE_MESHFLOW_SLEEP = exports.HMSH_CODE_MESHFLOW_PROXY = exports.HMSH_CODE_MESHFLOW_MAXED = exports.HMSH_CODE_MESHFLOW_FATAL = exports.HMSH_CODE_MESHFLOW_CHILD = exports.StreamStatus = exports.SerializerService = exports.HotMesh = exports.sleepImmediate = exports.s = exports.guid = exports.deterministicRandom = exports.asyncLocalStorage = exports.KeyType = exports.KeyService = exports.MeshFlowWaitForError = exports.MeshFlowTimeoutError = exports.MeshFlowSleepError = exports.MeshFlowRetryError = exports.MeshFlowProxyError = exports.MeshFlowMaxedError = exports.MeshFlowFatalError = exports.MeshFlowChildError = void 0;
-const errors_1 = require("../../../modules/errors");
-Object.defineProperty(exports, "MeshFlowChildError", { enumerable: true, get: function () { return errors_1.MeshFlowChildError; } });
-Object.defineProperty(exports, "MeshFlowFatalError", { enumerable: true, get: function () { return errors_1.MeshFlowFatalError; } });
-Object.defineProperty(exports, "MeshFlowMaxedError", { enumerable: true, get: function () { return errors_1.MeshFlowMaxedError; } });
-Object.defineProperty(exports, "MeshFlowProxyError", { enumerable: true, get: function () { return errors_1.MeshFlowProxyError; } });
-Object.defineProperty(exports, "MeshFlowRetryError", { enumerable: true, get: function () { return errors_1.MeshFlowRetryError; } });
-Object.defineProperty(exports, "MeshFlowSleepError", { enumerable: true, get: function () { return errors_1.MeshFlowSleepError; } });
-Object.defineProperty(exports, "MeshFlowTimeoutError", { enumerable: true, get: function () { return errors_1.MeshFlowTimeoutError; } });
-Object.defineProperty(exports, "MeshFlowWaitForError", { enumerable: true, get: function () { return errors_1.MeshFlowWaitForError; } });
-const key_1 = require("../../../modules/key");
-Object.defineProperty(exports, "KeyService", { enumerable: true, get: function () { return key_1.KeyService; } });
-Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return key_1.KeyType; } });
-const storage_1 = require("../../../modules/storage");
-Object.defineProperty(exports, "asyncLocalStorage", { enumerable: true, get: function () { return storage_1.asyncLocalStorage; } });
-const utils_1 = require("../../../modules/utils");
-Object.defineProperty(exports, "deterministicRandom", { enumerable: true, get: function () { return utils_1.deterministicRandom; } });
-Object.defineProperty(exports, "guid", { enumerable: true, get: function () { return utils_1.guid; } });
-Object.defineProperty(exports, "s", { enumerable: true, get: function () { return utils_1.s; } });
-Object.defineProperty(exports, "sleepImmediate", { enumerable: true, get: function () { return utils_1.sleepImmediate; } });
-const hotmesh_1 = require("../../hotmesh");
-Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
-const serializer_1 = require("../../serializer");
-Object.defineProperty(exports, "SerializerService", { enumerable: true, get: function () { return serializer_1.SerializerService; } });
-const stream_1 = require("../../../types/stream");
-Object.defineProperty(exports, "StreamStatus", { enumerable: true, get: function () { return stream_1.StreamStatus; } });
-const enums_1 = require("../../../modules/enums");
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_CHILD", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_CHILD; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_FATAL", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_FATAL; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_MAXED", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_MAXED; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_PROXY", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_PROXY; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_SLEEP", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_SLEEP; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_TIMEOUT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_TIMEOUT; } });
-Object.defineProperty(exports, "HMSH_CODE_MESHFLOW_WAIT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MESHFLOW_WAIT; } });
-Object.defineProperty(exports, "HMSH_MESHFLOW_EXP_BACKOFF", { enumerable: true, get: function () { return enums_1.HMSH_MESHFLOW_EXP_BACKOFF; } });
-Object.defineProperty(exports, "HMSH_MESHFLOW_MAX_ATTEMPTS", { enumerable: true, get: function () { return enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS; } });
-Object.defineProperty(exports, "HMSH_MESHFLOW_MAX_INTERVAL", { enumerable: true, get: function () { return enums_1.HMSH_MESHFLOW_MAX_INTERVAL; } });
-const telemetry_1 = require("../../telemetry");
-Object.defineProperty(exports, "TelemetryService", { enumerable: true, get: function () { return telemetry_1.TelemetryService; } });
-const search_1 = require("../search");
-Object.defineProperty(exports, "Search", { enumerable: true, get: function () { return search_1.Search; } });
-const worker_1 = require("../worker");
-Object.defineProperty(exports, "WorkerService", { enumerable: true, get: function () { return worker_1.WorkerService; } });

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

@@ -1,6 +0,0 @@
-import { WorkflowContext } from './common';
-/**
- * Returns the current workflow context, restored from storage.
- * @returns {WorkflowContext} The current workflow context.
- */
-export declare function getContext(): WorkflowContext;

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContext = void 0;
-const common_1 = require("./common");
-/**
- * Returns the current workflow context, restored from storage.
- * @returns {WorkflowContext} The current workflow context.
- */
-function getContext() {
-    const store = common_1.asyncLocalStorage.getStore();
-    const workflowId = store.get('workflowId');
-    const replay = store.get('replay');
-    const cursor = store.get('cursor');
-    const interruptionRegistry = store.get('interruptionRegistry');
-    const workflowDimension = store.get('workflowDimension') ?? '';
-    const workflowTopic = store.get('workflowTopic');
-    const connection = store.get('connection');
-    const namespace = store.get('namespace');
-    const originJobId = store.get('originJobId');
-    const workflowTrace = store.get('workflowTrace');
-    const canRetry = store.get('canRetry');
-    const workflowSpan = store.get('workflowSpan');
-    const expire = store.get('expire');
-    const COUNTER = store.get('counter');
-    const raw = store.get('raw');
-    return {
-        canRetry,
-        COUNTER,
-        counter: COUNTER.counter,
-        cursor,
-        interruptionRegistry,
-        connection,
-        expire,
-        namespace,
-        originJobId,
-        raw,
-        replay,
-        workflowId,
-        workflowDimension,
-        workflowTopic,
-        workflowTrace,
-        workflowSpan,
-    };
-}
-exports.getContext = getContext;

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

@@ -1,7 +0,0 @@
-/**
- * Determines if a replayed execution result already exists for the given prefix.
- * @private
- * @param {string} prefix - Identifier prefix (e.g., 'proxy', 'child', 'start', 'wait', etc.)
- * @returns {Promise<[boolean, number, any]>} A tuple: [alreadyRan, executionIndex, restoredData]
- */
-export declare function didRun(prefix: string): Promise<[boolean, number, any]>;