@hotmeshio/hotmesh 0.3.28 → 0.3.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Serverless Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/types/manifest.ts

@@ -24,16 +24,26 @@ export type EntityInstanceTypes = MeshOS;
 
 export type SubclassType<T extends MeshOS = MeshOS> = new (...args: any[]) => T;
 export type Entity = {
-  name: string;
+  name: string;                 //can be set via static config
   label: string;
-  schema: WorkflowSearchSchema;
+  /**
+   * A more-specific value for workers when targeting version-specifc
+   * or priority-specific task queues.
+   * @default default
+   */
+  taskQueue?: string;           //can be set via static config
+  schema: WorkflowSearchSchema; //can be st via static config
   class: SubclassType;
 };
 
 export type Namespace = {
   name: string;
+  /**
+   * @deprecated; unused; name is the type; label is human-readable
+   */
   type: string;
   label: string;
+  module: 'hotmesh' | 'meshcall' | 'meshflow' | 'meshdata' | 'meshos';
   entities: Entity[];
 };
 

package/types/provider.ts

@@ -69,6 +69,13 @@ export type ProviderConfig = {
   options: StringAnyType;
   /* 'redis' (Class) | 'ioredis' (Class) | 'postgres' (Client module) | 'postgres.pool' | 'postgres.poolclient', 'nats' */
   provider?: string;
+  /**
+   * If provided and if true, the engine router instance will
+   * be initialized as a readonly instance and will not consume
+   * messages from the stream channel. An engine in readonly mode
+   * can still read/write to the store and can still pub/sub events.
+   */
+  readonly?: boolean;
 };
 
 export type ProvidersConfig = {
@@ -77,6 +84,13 @@ export type ProvidersConfig = {
   stream: ProviderConfig;
   pub?: ProviderConfig;
   search?: ProviderConfig;
+  /**
+   * If provided and if true, the engine router instance will
+   * be initialized as a readonly instance and will not consume
+   * messages from the stream channel. An engine in readonly mode
+   * can still read/write to the store and can still pub/sub events.
+   */
+  readonly?: boolean;
 };
 
 export interface SetOptions {

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

@@ -1,35 +0,0 @@
-import { HotMesh } from '../hotmesh';
-import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOptions } from '../../types/meshflow';
-import { JobInterruptOptions } from '../../types/job';
-import { StringAnyType, StringScalarType, StringStringType } from '../../types/serializer';
-import { MeshFlowChildErrorType, MeshFlowProxyErrorType } from '../../types/error';
-import { Search } from './search';
-export declare class WorkflowService {
-    constructor();
-    static didRun(prefix: string): Promise<[boolean, number, any]>;
-    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
-    static trace(attributes: StringScalarType, config?: {
-        once: boolean;
-    }): Promise<boolean>;
-    static enrich(fields: StringStringType): Promise<boolean>;
-    static emit(events: StringAnyType, config?: {
-        once: boolean;
-    }): Promise<boolean>;
-    static getContext(): WorkflowContext;
-    static getHotMesh(): Promise<HotMesh>;
-    static execChild<T>(options: WorkflowOptions): Promise<T>;
-    static executeChild: typeof WorkflowService.execChild;
-    static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): MeshFlowChildErrorType;
-    static startChild(options: WorkflowOptions): Promise<string>;
-    static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
-    static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
-    static getProxyInterruptPayload(context: WorkflowContext, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): MeshFlowProxyErrorType;
-    static search(): Promise<Search>;
-    static random(): number;
-    static signal(signalId: string, data: Record<any, any>): Promise<string>;
-    static hook(options: HookOptions): Promise<string>;
-    static interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;
-    static all<T>(...promises: Promise<T>[]): Promise<T[]>;
-    static sleepFor(duration: string): Promise<number>;
-    static waitFor<T>(signalId: string): Promise<T>;
-}

package/build/services/meshflow/workflow.js

@@ -1,403 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowService = void 0;
-const errors_1 = require("../../modules/errors");
-const key_1 = require("../../modules/key");
-const storage_1 = require("../../modules/storage");
-const utils_1 = require("../../modules/utils");
-const serializer_1 = require("../serializer");
-const stream_1 = require("../../types/stream");
-const enums_1 = require("../../modules/enums");
-const telemetry_1 = require("../telemetry");
-const search_1 = require("./search");
-const worker_1 = require("./worker");
-class WorkflowService {
-    constructor() { }
-    static async didRun(prefix) {
-        const { COUNTER, replay, workflowDimension } = WorkflowService.getContext();
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
-        if (sessionId in replay) {
-            const restored = serializer_1.SerializerService.fromString(replay[sessionId]);
-            return [true, execIndex, restored];
-        }
-        return [false, execIndex, null];
-    }
-    static async isSideEffectAllowed(hotMeshClient, prefix) {
-        const store = storage_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 = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const searchClient = hotMeshClient.engine.search;
-        const guidValue = await searchClient.incrementFieldByFloat(workflowGuid, sessionId, 1);
-        return guidValue === 1;
-    }
-    static async trace(attributes, config = { once: true }) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const connection = store.get('connection');
-        const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        const { raw, COUNTER } = this.getContext();
-        const { trc: traceId, spn: spanId, aid: activityId } = raw.metadata;
-        if (!config.once ||
-            await WorkflowService.isSideEffectAllowed(hotMeshClient, 'trace')) {
-            return await telemetry_1.TelemetryService.traceActivity(namespace, attributes, activityId, traceId, spanId, COUNTER.counter);
-        }
-        return true;
-    }
-    static async enrich(fields) {
-        const search = await WorkflowService.search();
-        await search.set(fields);
-        return true;
-    }
-    static async emit(events, config = { once: true }) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const connection = store.get('connection');
-        const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        if (!config.once ||
-            await WorkflowService.isSideEffectAllowed(hotMeshClient, 'emit')) {
-            for (const [topic, message] of Object.entries(events)) {
-                await hotMeshClient.quorum.pub({ topic, message });
-            }
-        }
-        return true;
-    }
-    static getContext() {
-        const store = storage_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,
-        };
-    }
-    static async getHotMesh() {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const connection = store.get('connection');
-        const namespace = store.get('namespace');
-        return await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-    }
-    static async execChild(options) {
-        const isStartChild = options.await === false;
-        const prefix = isStartChild ? 'start' : 'child';
-        const [didRun, execIndex, result] = await WorkflowService.didRun(prefix);
-        const context = WorkflowService.getContext();
-        const { canRetry, interruptionRegistry } = context;
-        if (didRun) {
-            if (result?.$error &&
-                (!result.$error.is_stream_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 === enums_1.HMSH_CODE_MESHFLOW_FATAL) {
-                        throw new errors_1.MeshFlowFatalError(message, stack);
-                    }
-                    else if (code == enums_1.HMSH_CODE_MESHFLOW_MAXED) {
-                        throw new errors_1.MeshFlowMaxedError(message, stack);
-                    }
-                    else if (code == enums_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
-                        throw new errors_1.MeshFlowTimeoutError(message, stack);
-                    }
-                    else {
-                        throw new errors_1.MeshFlowRetryError(message, stack);
-                    }
-                }
-                return result.$error;
-            }
-            else if (!result?.$error) {
-                return result.data;
-            }
-        }
-        const interruptionMessage = WorkflowService.getChildInterruptPayload(context, options, execIndex);
-        interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_MESHFLOW_CHILD,
-            ...interruptionMessage,
-        });
-        await (0, utils_1.sleepImmediate)();
-        throw new errors_1.MeshFlowChildError(interruptionMessage);
-    }
-    static 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, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
-        }
-        else {
-            childJobId = `-${options.workflowName}-${(0, utils_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 ?? enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
-            index: execIndex,
-            maximumAttempts: options?.config?.maximumAttempts ?? enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
-            maximumInterval: (0, utils_1.s)(options?.config?.maximumInterval ?? enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
-            originJobId: originJobId ?? workflowId,
-            expire: options.expire ?? expire,
-            persistent: options.persistent,
-            signalIn: options.signalIn,
-            parentWorkflowId,
-            workflowDimension: workflowDimension,
-            workflowId: childJobId,
-            workflowTopic,
-        };
-    }
-    static async startChild(options) {
-        return WorkflowService.execChild({ ...options, await: false });
-    }
-    static proxyActivities(options) {
-        if (options.activities) {
-            worker_1.WorkerService.registerActivities(options.activities);
-        }
-        const proxy = {};
-        const keys = Object.keys(worker_1.WorkerService.activityRegistry);
-        if (keys.length) {
-            keys.forEach((key) => {
-                const activityFunction = worker_1.WorkerService.activityRegistry[key];
-                proxy[key] = WorkflowService.wrapActivity(key, options);
-            });
-        }
-        return proxy;
-    }
-    static wrapActivity(activityName, options) {
-        return async function () {
-            const [didRun, execIndex, result] = await WorkflowService.didRun('proxy');
-            if (didRun) {
-                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 === enums_1.HMSH_CODE_MESHFLOW_FATAL) {
-                            throw new errors_1.MeshFlowFatalError(message, stack);
-                        }
-                        else if (code == enums_1.HMSH_CODE_MESHFLOW_MAXED) {
-                            throw new errors_1.MeshFlowMaxedError(message, stack);
-                        }
-                        else if (code == enums_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
-                            throw new errors_1.MeshFlowTimeoutError(message, stack);
-                        }
-                    }
-                    return result.$error;
-                }
-                return result.data;
-            }
-            const context = WorkflowService.getContext();
-            const { interruptionRegistry } = context;
-            const interruptionMessage = WorkflowService.getProxyInterruptPayload(context, activityName, execIndex, Array.from(arguments), options);
-            interruptionRegistry.push({
-                code: enums_1.HMSH_CODE_MESHFLOW_PROXY,
-                ...interruptionMessage,
-            });
-            await (0, utils_1.sleepImmediate)();
-            throw new errors_1.MeshFlowProxyError(interruptionMessage);
-        };
-    }
-    static 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, utils_1.s)(options.retryPolicy.maximumInterval);
-        }
-        return {
-            arguments: args,
-            workflowDimension: 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,
-        };
-    }
-    static async search() {
-        const store = storage_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 worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        const searchSessionId = `-search${workflowDimension}-${execIndex}`;
-        return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
-    }
-    static random() {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const COUNTER = store.get('counter');
-        const seed = COUNTER.counter = COUNTER.counter + 1;
-        return (0, utils_1.deterministicRandom)(seed);
-    }
-    static async signal(signalId, data) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const connection = store.get('connection');
-        const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
-            return await hotMeshClient.hook(`${namespace}.wfs.signal`, {
-                id: signalId,
-                data,
-            });
-        }
-    }
-    static async hook(options) {
-        const { workflowId, connection, namespace, workflowTopic } = WorkflowService.getContext();
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        if (await WorkflowService.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 || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
-                maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
-                maximumInterval: (0, utils_1.s)(options?.config?.maximumInterval ?? enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
-            };
-            return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
-        }
-    }
-    static async interrupt(jobId, options = {}) {
-        const { workflowTopic, connection, namespace } = WorkflowService.getContext();
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {
-            return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
-        }
-    }
-    static async all(...promises) {
-        await new Promise((resolve) => setTimeout(resolve, 1));
-        return await Promise.all(promises);
-    }
-    static async sleepFor(duration) {
-        const [didRun, execIndex, result] = await WorkflowService.didRun('sleep');
-        if (didRun) {
-            return result.duration;
-        }
-        const store = storage_1.asyncLocalStorage.getStore();
-        const interruptionRegistry = store.get('interruptionRegistry');
-        const workflowId = store.get('workflowId');
-        const workflowDimension = store.get('workflowDimension') ?? '';
-        const interruptionMessage = {
-            workflowId,
-            duration: (0, utils_1.s)(duration),
-            index: execIndex,
-            workflowDimension,
-        };
-        interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_MESHFLOW_SLEEP,
-            ...interruptionMessage,
-        });
-        await (0, utils_1.sleepImmediate)();
-        throw new errors_1.MeshFlowSleepError(interruptionMessage);
-    }
-    static async waitFor(signalId) {
-        const [didRun, execIndex, result] = await WorkflowService.didRun('wait');
-        if (didRun) {
-            return result.data.data;
-        }
-        const store = storage_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: enums_1.HMSH_CODE_MESHFLOW_WAIT,
-            ...interruptionMessage,
-        });
-        await (0, utils_1.sleepImmediate)();
-        throw new errors_1.MeshFlowWaitForError(interruptionMessage);
-    }
-}
-WorkflowService.executeChild = WorkflowService.execChild;
-exports.WorkflowService = WorkflowService;