@hotmeshio/hotmesh 0.0.7 → 0.0.9

package/build/cjs/package.json

@@ -1,80 +0,0 @@
-{
-    "name": "@hotmeshio/hotmesh",
-    "version": "0.0.7",
-    "description": "Durable Workflows",
-    "main": "build/cjs/index.js",
-    "module": "build/esm/index.js",
-    "types": "build/cjs/index.d.ts",
-    "exports": {
-        "import": "./build/esm/index.js",
-        "require": "./build/cjs/index.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hotmeshio/sdk-typescript.git"
-    },
-    "homepage": "https://github.com/hotmeshio/sdk-typescript#readme",
-    "publishConfig": {
-        "access": "public"
-    },
-    "scripts": {
-        "clean": "rimraf ./build",
-        "build:cjs": "tsc --build tsconfig.cjs.json",
-        "build:esm": "tsc --build tsconfig.esm.json",
-        "build": "npm run build:cjs && npm run build:esm",
-        "clean-build": "npm run clean && npm run build",
-        "lint": "eslint . --ext .ts",
-        "lint:fix": "eslint . --fix --ext .ts",
-        "start": "ts-node src/index.ts",
-        "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
-        "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
-        "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:parallel": "NODE_ENV=test jest ./tests/functional/parallel/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sequence": "NODE_ENV=test jest ./tests/functional/sequence/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:retry": "NODE_ENV=test jest ./tests/functional/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
-    },
-    "keywords": [],
-    "author": "luke.birdeau@gmail.com",
-    "license": "SEE LICENSE IN LICENSE",
-    "dependencies": {
-        "@apidevtools/json-schema-ref-parser": "^10.1.0",
-        "@opentelemetry/api": "^1.4.1",
-        "js-yaml": "^4.1.0",
-        "ms": "^2.1.3",
-        "uuid": "^9.0.1",
-        "winston": "^3.8.2"
-    },
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
-        "@typescript-eslint/eslint-plugin": "^5.56.0",
-        "@typescript-eslint/parser": "^5.56.0",
-        "eslint": "^8.36.0",
-        "ioredis": "^5.3.2",
-        "jest": "^29.5.0",
-        "redis": "^4.6.6",
-        "rimraf": "^4.4.1",
-        "ts-jest": "^29.0.5",
-        "ts-node": "^10.9.1",
-        "ts-node-dev": "^2.0.0",
-        "typescript": "^5.0.4"
-    }
-}

package/build/cjs/services/activities/index.d.ts

@@ -1,15 +0,0 @@
-import { Activity } from './activity';
-import { Await } from './await';
-import { Worker } from './worker';
-import { Iterate } from './iterate';
-import { Emit } from './emit';
-import { Trigger } from './trigger';
-declare const _default: {
-    activity: typeof Activity;
-    await: typeof Await;
-    iterate: typeof Iterate;
-    emit: typeof Emit;
-    trigger: typeof Trigger;
-    worker: typeof Worker;
-};
-export default _default;

package/build/cjs/services/activities/worker.js

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
-const errors_1 = require("../../modules/errors");
-const activity_1 = require("./activity");
-const collator_1 = require("../collator");
-const stream_1 = require("../../types/stream");
-const telemetry_1 = require("../telemetry");
-class Worker extends activity_1.Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        super(config, data, metadata, hook, engine, context);
-    }
-    //********  INITIAL ENTRY POINT (A)  ********//
-    async process() {
-        this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        let telemetry;
-        try {
-            this.setLeg(1);
-            await collator_1.CollatorService.notarizeEntry(this);
-            await this.getState();
-            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            this.mapInputData();
-            const multi = this.store.getMulti();
-            //await this.registerTimeout();
-            await collator_1.CollatorService.authorizeReentry(this, multi);
-            await this.setState(multi);
-            await this.setStatus(0, multi);
-            const multiResponse = await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            const messageId = await this.execActivity();
-            telemetry.setActivityAttributes({
-                'app.activity.mid': messageId,
-                'app.job.jss': jobStatus
-            });
-            //TODO: UPDATE ACTIVITY STATE (LEG 1 EXIT)
-            return this.context.metadata.aid;
-        }
-        catch (error) {
-            if (error instanceof errors_1.GetStateError) {
-                this.logger.error('worker-get-state-error', error);
-            }
-            else {
-                console.error(error);
-                this.logger.error('worker-process-error', error);
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        }
-    }
-    async execActivity() {
-        const streamData = {
-            metadata: {
-                jid: this.context.metadata.jid,
-                dad: this.metadata.dad,
-                aid: this.metadata.aid,
-                topic: this.config.subtype,
-                spn: this.context['$self'].output.metadata.l1s,
-                trc: this.context.metadata.trc,
-            },
-            data: this.context.data
-        };
-        if (this.config.retry) {
-            streamData.policies = {
-                retry: this.config.retry
-            };
-        }
-        return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData));
-    }
-    //********  SIGNAL RE-ENTRY POINT (DUPLEX LEG 2 of 2)  ********//
-    async processEvent(status = stream_1.StreamStatus.SUCCESS, code = 200) {
-        this.setLeg(2);
-        const jid = this.context.metadata.jid;
-        const aid = this.metadata.aid;
-        this.status = status;
-        this.code = code;
-        this.logger.debug('worker-process-event', { topic: this.config.subtype, jid, aid, status, code });
-        let telemetry;
-        try {
-            await this.getState();
-            const aState = await collator_1.CollatorService.notarizeReentry(this);
-            this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
-            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            let isComplete = collator_1.CollatorService.isActivityComplete(this.context.metadata.js);
-            if (isComplete) {
-                this.logger.warn('worker-process-event-duplicate', { jid, aid });
-                this.logger.debug('worker-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
-                return;
-            }
-            telemetry.startActivitySpan(this.leg);
-            if (status === stream_1.StreamStatus.PENDING) {
-                await this.processPending(telemetry);
-            }
-            else if (status === stream_1.StreamStatus.SUCCESS) {
-                await this.processSuccess(telemetry);
-            }
-            else {
-                await this.processError(telemetry);
-            }
-        }
-        catch (error) {
-            this.logger.error('worker-process-event-error', error);
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('worker-process-event-end', { jid, aid });
-        }
-    }
-    async processPending(telemetry) {
-        this.bindActivityData('output');
-        this.adjacencyList = await this.filterAdjacent();
-        this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await collator_1.CollatorService.notarizeContinuation(this, multi);
-        await this.setStatus(this.adjacencyList.length, multi);
-        const multiResponse = await multi.exec();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async processSuccess(telemetry) {
-        this.bindActivityData('output');
-        this.adjacencyList = await this.filterAdjacent();
-        this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await collator_1.CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(this.adjacencyList.length - 1, multi);
-        const multiResponse = await multi.exec();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async processError(telemetry) {
-        this.bindActivityError(this.data);
-        this.adjacencyList = await this.filterAdjacent();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await collator_1.CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(this.adjacencyList.length - 1, multi);
-        const multiResponse = await multi.exec();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async transitionAdjacent(multiResponse, telemetry) {
-        telemetry.mapActivityAttributes();
-        const jobStatus = this.resolveStatus(multiResponse);
-        const attrs = { 'app.job.jss': jobStatus };
-        const messageIds = await this.transition(this.adjacencyList, jobStatus);
-        if (messageIds.length) {
-            attrs['app.activity.mids'] = messageIds.join(',');
-        }
-        telemetry.setActivityAttributes(attrs);
-    }
-}
-exports.Worker = Worker;

package/build/cjs/services/collator/index.d.ts

@@ -1,56 +0,0 @@
-import { RedisMulti } from '../../types/redis';
-import { CollationStage } from '../../types/collator';
-import { ActivityDuplex } from '../../types/activity';
-import { HotMeshGraph } from '../../types/hotmesh';
-import { Activity } from '../activities/activity';
-declare class CollatorService {
-    static targetLength: number;
-    static getDimensionalAddress(activity: Activity): Record<string, string>;
-    static notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static authorizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeContinuation(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static getDigitAtIndex(num: number, targetDigitIndex: number): number | null;
-    static getDimensionalIndex(num: number): number | null;
-    static isDuplicate(num: number, targetDigitIndex: number): boolean;
-    static isInactive(num: number): boolean;
-    static isPrimed(amount: number, leg: ActivityDuplex): boolean;
-    static verifyInteger(amount: number, leg: ActivityDuplex, stage: CollationStage): void;
-    static getDimensionsById(ancestors: string[], dad: string): Record<string, string>;
-    /**
-     * All non-trigger activities are assigned a status seed by their parent
-     */
-    static getSeed(): string;
-    /**
-     * All trigger activities are assigned a status seed in a completed state
-     */
-    static getTriggerSeed(): string;
-    /**
-     * entry point for compiler-type activities. This is called by the compiler
-     * to bind the sorted activity IDs to the trigger activity. These are then used
-     * at runtime by the activities to track job/activity status.
-     * @param graphs
-     */
-    static compile(graphs: HotMeshGraph[]): void;
-    /**
-     * binds the ancestor array to each activity.
-     * Used in conjunction with the dimensional
-     *  address (dad). If dad is `,0,1,0,0` and the
-     * ancestor array is `['t1', 'a1', 'a2']` for
-     * activity 'a3', then the SAVED DAD
-     * will always have the trailing
-     * 0's removed. This ensures that the addressing
-     * remains consistent even if the graph changes.
-     *   id    DAD           SAVED DAD
-     * * t1 => ,0        =>  [empty]
-     * * a1 => ,0,1      =>  ,0,1
-     * * a2 => ,0,1,0    =>  ,0,1
-     * * a3 => ,0,1,0,0  =>  ,0,1
-     *
-     */
-    static bindAncestorArray(graphs: HotMeshGraph[]): void;
-    static isActivityComplete(status: number): boolean;
-}
-export { CollatorService };

package/build/cjs/services/durable/worker.js

@@ -1,298 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerService = void 0;
-const asyncLocalStorage_1 = require("./asyncLocalStorage");
-const hotmesh_1 = require("../hotmesh");
-const stream_1 = require("../../types/stream");
-const factory_1 = require("./factory");
-/*
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as activities from './activities';
-
-async function run() {
-  const connection = await NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Worker.create({
-    connection,
-    namespace: 'default',
-    taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-*/
-class WorkerService {
-    static async activateWorkflow(hotMesh, topic, factory) {
-        const version = '1';
-        const app = await hotMesh.engine.store.getApp(topic);
-        const appVersion = app?.version;
-        if (!appVersion) {
-            try {
-                await hotMesh.deploy(factory(topic, version));
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
-                throw err;
-            }
-        }
-        else if (app && !app.active) {
-            try {
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('durable-worker-activate-err', err);
-                throw err;
-            }
-        }
-    }
-    /**
-     * The `worker` calls `registerActivities` immediately BEFORE
-     * dynamically importing the user's workflow module. That file
-     * contains a call, `proxyActivities`, which needs this info.
-     *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
-     * the activities are loaded, there will be items in the registry,
-     * allowing proxyActivities to succeed.
-     */
-    static registerActivities(activities) {
-        if (typeof activities === 'function') {
-            WorkerService.activityRegistry[activities.name] = activities;
-        }
-        else {
-            Object.keys(activities).forEach(key => {
-                WorkerService.activityRegistry[activities[key].name] = activities[key];
-            });
-        }
-        return WorkerService.activityRegistry;
-    }
-    static async create(config) {
-        //always call `registerActivities` before `import`
-        WorkerService.connection = config.connection;
-        WorkerService.registerActivities(config.activities);
-        const workflow = await Promise.resolve(`${config.workflowsPath}`).then(s => __importStar(require(s)));
-        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();
-        const activityRunner = await worker.initActivityWorkflow(config, activityTopic);
-        await WorkerService.activateWorkflow(activityRunner, activityTopic, factory_1.getActivityYAML);
-        worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
-        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, factory_1.getWorkflowYAML);
-        return worker;
-    }
-    static resolveWorkflowTarget(workflow) {
-        let workflowFunction;
-        if (typeof workflow === 'function') {
-            workflowFunction = workflow;
-        }
-        else {
-            const workflowFunctionNames = Object.keys(workflow);
-            workflowFunction = workflow[workflowFunctionNames[workflowFunctionNames.length - 1]];
-            return WorkerService.resolveWorkflowTarget(workflowFunction);
-        }
-        return [workflowFunction.name, workflowFunction];
-    }
-    async run() {
-        if (this.workflowRunner) {
-            this.workflowRunner.engine.logger.info('WorkerService is running');
-        }
-        else {
-            console.log('WorkerService is running');
-        }
-    }
-    async initActivityWorkflow(config, activityTopic) {
-        const redisConfig = {
-            class: config.connection.class,
-            options: config.connection.options
-        };
-        const hmshInstance = await hotmesh_1.HotMeshService.init({
-            appId: activityTopic,
-            engine: { redis: redisConfig },
-            workers: [
-                { topic: activityTopic,
-                    redis: redisConfig,
-                    callback: this.wrapActivityFunctions().bind(this)
-                }
-            ]
-        });
-        WorkerService.instances.set(activityTopic, hmshInstance);
-        return hmshInstance;
-    }
-    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) {
-                console.error(err);
-                //todo (make retry configurable)
-                return {
-                    status: stream_1.StreamStatus.PENDING,
-                    metadata: { ...data.metadata },
-                    data: { error: err }
-                };
-            }
-        };
-    }
-    async activateActivityWorkflow(hotMesh, activityTopic) {
-        const version = '1';
-        const app = await hotMesh.engine.store.getApp(activityTopic);
-        const appVersion = app?.version;
-        if (isNaN(appVersion)) {
-            try {
-                await hotMesh.deploy((0, factory_1.getActivityYAML)(activityTopic, version));
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                console.log('durable-worker-activity-deploy-activate-error', err);
-                throw err;
-            }
-        }
-        else if (app && !app.active) {
-            try {
-                await hotMesh.activate(version);
-            }
-            catch (err) {
-                hotMesh.engine.logger.error('durable-worker-activity-activate-err', err);
-                throw err;
-            }
-        }
-    }
-    async initWorkerWorkflow(config, workflowTopic, workflowFunction) {
-        const redisConfig = {
-            class: config.connection.class,
-            options: config.connection.options
-        };
-        const hmshInstance = await hotmesh_1.HotMeshService.init({
-            appId: workflowTopic,
-            engine: { redis: redisConfig },
-            workers: [
-                { topic: workflowTopic,
-                    redis: redisConfig,
-                    callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic).bind(this)
-                }
-            ]
-        });
-        WorkerService.instances.set(workflowTopic, hmshInstance);
-        return hmshInstance;
-    }
-    wrapWorkflowFunction(workflowFunction, workflowTopic) {
-        return async (data) => {
-            try {
-                //incoming data payload has arguments and workflowId
-                const workflowInput = data.data;
-                const context = new Map();
-                const counter = { counter: 0 };
-                context.set('counter', counter);
-                context.set('workflowId', workflowInput.workflowId);
-                context.set('workflowTopic', workflowTopic);
-                context.set('workflowName', workflowTopic.split('-').pop());
-                context.set('workflowTrace', data.metadata.trc);
-                context.set('workflowSpan', data.metadata.spn);
-                const workflowResponse = await asyncLocalStorage_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 }
-                };
-            }
-            catch (err) {
-                //todo: (retryable error types)
-                return {
-                    code: 500,
-                    status: stream_1.StreamStatus.PENDING,
-                    metadata: { ...data.metadata },
-                    data: { error: err }
-                };
-            }
-        };
-    }
-    static async shutdown() {
-        for (const [key, value] of WorkerService.instances) {
-            const hotMesh = await value;
-            await hotMesh.stop();
-        }
-    }
-}
-_a = WorkerService;
-WorkerService.activityRegistry = {}; //user's activities
-WorkerService.instances = new Map();
-WorkerService.getHotMesh = async (worflowTopic) => {
-    if (WorkerService.instances.has(worflowTopic)) {
-        return await WorkerService.instances.get(worflowTopic);
-    }
-    const hotMesh = hotmesh_1.HotMeshService.init({
-        appId: worflowTopic,
-        engine: { redis: { ...WorkerService.connection } }
-    });
-    WorkerService.instances.set(worflowTopic, hotMesh);
-    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, factory_1.getWorkflowYAML);
-    return hotMesh;
-};
-WorkerService.Context = {
-    info: () => {
-        return {
-            workflowId: '',
-            workflowTopic: '',
-        };
-    },
-};
-exports.WorkerService = WorkerService;