@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/{meshflow → memflow}/worker.js

@@ -16,12 +16,12 @@ const factory_1 = require("./schemas/factory");
  *
  * @example
  * ```typescript
- * import { MeshFlow } from '@hotmeshio/hotmesh';
+ * import { MemFlow } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
  * import * as workflows from './workflows';
  *
  * async function run() {
- *   const worker = await MeshFlow.Worker.create({
+ *   const worker = await MemFlow.Worker.create({
  *     connection: {
  *       class: Postgres,
  *       options: { connectionString: 'postgres://user:password@localhost:5432/db' }
@@ -67,7 +67,7 @@ class WorkerService {
                 await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
-                hotMesh.engine.logger.error('meshflow-worker-deploy-activate-err', err);
+                hotMesh.engine.logger.error('memflow-worker-deploy-activate-err', err);
                 throw err;
             }
         }
@@ -76,7 +76,7 @@ class WorkerService {
                 await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
-                hotMesh.engine.logger.error('meshflow-worker-activate-err', err);
+                hotMesh.engine.logger.error('memflow-worker-activate-err', err);
                 throw err;
             }
         }
@@ -108,12 +108,12 @@ class WorkerService {
      *
      * @example
      * ```typescript
-     * import { MeshFlow } from '@hotmeshio/hotmesh';
+     * import { MemFlow } from '@hotmeshio/hotmesh';
      * import { Client as Postgres } from 'pg';
      * import * as workflows from './workflows';
      *
      * async function run() {
-     *   const worker = await MeshFlow.Worker.create({
+     *   const worker = await MemFlow.Worker.create({
      *     connection: {
      *       class: Postgres,
      *       options: {
@@ -162,7 +162,7 @@ class WorkerService {
      * Run the connected worker; no-op (unnecessary to call)
      */
     async run() {
-        this.workflowRunner.engine.logger.info('meshflow-worker-running');
+        this.workflowRunner.engine.logger.info('memflow-worker-running');
     }
     /**
      * @private
@@ -206,19 +206,19 @@ class WorkerService {
                 };
             }
             catch (err) {
-                this.activityRunner.engine.logger.error('meshflow-worker-activity-err', {
+                this.activityRunner.engine.logger.error('memflow-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)) {
+                if (!(err instanceof errors_1.MemFlowTimeoutError) &&
+                    !(err instanceof errors_1.MemFlowMaxedError) &&
+                    !(err instanceof errors_1.MemFlowFatalError)) {
                     //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,
+                        code: enums_1.HMSH_CODE_MEMFLOW_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
                             $error: {
@@ -230,7 +230,7 @@ class WorkerService {
                     };
                 }
                 return {
-                    //always returrn success (the MeshFlow module is just fine);
+                    //always returrn success (the MemFlow module is just fine);
                     //  it's the user's function that has failed
                     status: stream_1.StreamStatus.SUCCESS,
                     code: err.code,
@@ -333,7 +333,7 @@ class WorkerService {
                 if (isProcessing) {
                     return;
                 }
-                if (err instanceof errors_1.MeshFlowWaitForError ||
+                if (err instanceof errors_1.MemFlowWaitForError ||
                     interruptionRegistry.length > 1) {
                     isProcessing = true;
                     //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
@@ -343,10 +343,10 @@ class WorkerService {
                     const collatorFlowId = `${(0, utils_1.guid)()}$C`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_MESHFLOW_ALL,
+                        code: enums_1.HMSH_CODE_MEMFLOW_ALL,
                         metadata: { ...data.metadata },
                         data: {
-                            code: enums_1.HMSH_CODE_MESHFLOW_ALL,
+                            code: enums_1.HMSH_CODE_MEMFLOW_ALL,
                             items: [...interruptionRegistry],
                             size: interruptionRegistry.length,
                             workflowDimension: workflowDimension || '',
@@ -359,7 +359,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MeshFlowSleepError) {
+                else if (err instanceof errors_1.MemFlowSleepError) {
                     //return the sleep interruption
                     isProcessing = true;
                     return {
@@ -379,7 +379,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MeshFlowProxyError) {
+                else if (err instanceof errors_1.MemFlowProxyError) {
                     //return the proxyActivity interruption
                     isProcessing = true;
                     return {
@@ -409,7 +409,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MeshFlowChildError) {
+                else if (err instanceof errors_1.MemFlowChildError) {
                     //return the child interruption
                     isProcessing = true;
                     const msg = {
@@ -424,12 +424,12 @@ class WorkerService {
                         data: {
                             arguments: err.arguments,
                             await: err.await,
-                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
+                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_MEMFLOW_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),
+                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
+                            maximumInterval: err.maximumInterval || (0, utils_1.s)(enums_1.HMSH_MEMFLOW_MAX_INTERVAL),
                             originJobId: err.originJobId,
                             parentWorkflowId: err.parentWorkflowId,
                             expire: err.expire,
@@ -446,7 +446,7 @@ class WorkerService {
                 isProcessing = true;
                 return {
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
+                    code: err.code || new errors_1.MemFlowRetryError(err.message).code,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -454,7 +454,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
+                            code: err.code || new errors_1.MemFlowRetryError(err.message).code,
                         },
                     },
                 };

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

@@ -0,0 +1,20 @@
+import { MemFlowChildError, MemFlowFatalError, MemFlowMaxedError, MemFlowProxyError, MemFlowRetryError, MemFlowSleepError, MemFlowTimeoutError, MemFlowWaitForError } 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/memflow';
+import { JobInterruptOptions } from '../../../types/job';
+import { StreamCode, StreamStatus } from '../../../types/stream';
+import { StringAnyType, StringScalarType, StringStringType } from '../../../types/serializer';
+import { HMSH_CODE_MEMFLOW_CHILD, HMSH_CODE_MEMFLOW_FATAL, HMSH_CODE_MEMFLOW_MAXED, HMSH_CODE_MEMFLOW_PROXY, HMSH_CODE_MEMFLOW_SLEEP, HMSH_CODE_MEMFLOW_TIMEOUT, HMSH_CODE_MEMFLOW_WAIT, HMSH_MEMFLOW_EXP_BACKOFF, HMSH_MEMFLOW_MAX_ATTEMPTS, HMSH_MEMFLOW_MAX_INTERVAL } from '../../../modules/enums';
+import { MemFlowChildErrorType, MemFlowProxyErrorType } from '../../../types/error';
+import { TelemetryService } from '../../telemetry';
+import { QuorumMessage } from '../../../types';
+import { UserMessage } from '../../../types/quorum';
+import { Search } from '../search';
+import { WorkerService } from '../worker';
+import { Context } from '../context';
+import { ExecHookOptions } from './execHook';
+export { MemFlowChildError, MemFlowFatalError, MemFlowMaxedError, MemFlowProxyError, MemFlowRetryError, MemFlowSleepError, MemFlowTimeoutError, MemFlowWaitForError, KeyService, KeyType, asyncLocalStorage, deterministicRandom, guid, s, sleepImmediate, HotMesh, SerializerService, ActivityConfig, ChildResponseType, HookOptions, ExecHookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions, JobInterruptOptions, StreamCode, StreamStatus, StringAnyType, StringScalarType, StringStringType, HMSH_CODE_MEMFLOW_CHILD, HMSH_CODE_MEMFLOW_FATAL, HMSH_CODE_MEMFLOW_MAXED, HMSH_CODE_MEMFLOW_PROXY, HMSH_CODE_MEMFLOW_SLEEP, HMSH_CODE_MEMFLOW_TIMEOUT, HMSH_CODE_MEMFLOW_WAIT, HMSH_MEMFLOW_EXP_BACKOFF, HMSH_MEMFLOW_MAX_ATTEMPTS, HMSH_MEMFLOW_MAX_INTERVAL, MemFlowChildErrorType, MemFlowProxyErrorType, TelemetryService, QuorumMessage, UserMessage, Search, WorkerService, Context, };

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.WorkerService = exports.Search = exports.TelemetryService = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_CHILD = exports.StreamStatus = exports.SerializerService = exports.HotMesh = exports.sleepImmediate = exports.s = exports.guid = exports.deterministicRandom = exports.asyncLocalStorage = exports.KeyType = exports.KeyService = exports.MemFlowWaitForError = exports.MemFlowTimeoutError = exports.MemFlowSleepError = exports.MemFlowRetryError = exports.MemFlowProxyError = exports.MemFlowMaxedError = exports.MemFlowFatalError = exports.MemFlowChildError = void 0;
+const errors_1 = require("../../../modules/errors");
+Object.defineProperty(exports, "MemFlowChildError", { enumerable: true, get: function () { return errors_1.MemFlowChildError; } });
+Object.defineProperty(exports, "MemFlowFatalError", { enumerable: true, get: function () { return errors_1.MemFlowFatalError; } });
+Object.defineProperty(exports, "MemFlowMaxedError", { enumerable: true, get: function () { return errors_1.MemFlowMaxedError; } });
+Object.defineProperty(exports, "MemFlowProxyError", { enumerable: true, get: function () { return errors_1.MemFlowProxyError; } });
+Object.defineProperty(exports, "MemFlowRetryError", { enumerable: true, get: function () { return errors_1.MemFlowRetryError; } });
+Object.defineProperty(exports, "MemFlowSleepError", { enumerable: true, get: function () { return errors_1.MemFlowSleepError; } });
+Object.defineProperty(exports, "MemFlowTimeoutError", { enumerable: true, get: function () { return errors_1.MemFlowTimeoutError; } });
+Object.defineProperty(exports, "MemFlowWaitForError", { enumerable: true, get: function () { return errors_1.MemFlowWaitForError; } });
+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_MEMFLOW_CHILD", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_CHILD; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_FATAL", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_FATAL; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_MAXED", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_MAXED; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_PROXY", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_PROXY; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_SLEEP", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_SLEEP; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_TIMEOUT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_TIMEOUT; } });
+Object.defineProperty(exports, "HMSH_CODE_MEMFLOW_WAIT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_MEMFLOW_WAIT; } });
+Object.defineProperty(exports, "HMSH_MEMFLOW_EXP_BACKOFF", { enumerable: true, get: function () { return enums_1.HMSH_MEMFLOW_EXP_BACKOFF; } });
+Object.defineProperty(exports, "HMSH_MEMFLOW_MAX_ATTEMPTS", { enumerable: true, get: function () { return enums_1.HMSH_MEMFLOW_MAX_ATTEMPTS; } });
+Object.defineProperty(exports, "HMSH_MEMFLOW_MAX_INTERVAL", { enumerable: true, get: function () { return enums_1.HMSH_MEMFLOW_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; } });
+const context_1 = require("../context");
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/build/services/memflow/workflow/contextMethods.d.ts

@@ -0,0 +1,14 @@
+import { Context } from './common';
+/**
+ * Returns a context session handle for interacting with the workflow's JSONB context storage.
+ * @returns {Promise<Context>} A context session for workflow data.
+ *
+ * @example
+ * ```typescript
+ * const context = await workflow.context();
+ * await context.set({ user: { id: 123 } });
+ * await context.merge({ user: { name: "John" } });
+ * const user = await context.get("user");
+ * ```
+ */
+export declare function context(): Promise<Context>;

package/build/services/memflow/workflow/contextMethods.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = void 0;
+const common_1 = require("./common");
+/**
+ * Returns a context session handle for interacting with the workflow's JSONB context storage.
+ * @returns {Promise<Context>} A context session for workflow data.
+ *
+ * @example
+ * ```typescript
+ * const context = await workflow.context();
+ * await context.set({ user: { id: 123 } });
+ * await context.merge({ user: { name: "John" } });
+ * const user = await context.get("user");
+ * ```
+ */
+async function context() {
+    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 contextSessionId = `-context${workflowDimension}-${execIndex}`;
+    return new common_1.Context(workflowId, hotMeshClient, contextSessionId);
+}
+exports.context = context;

package/build/services/{meshflow → memflow}/workflow/execChild.js

@@ -27,10 +27,10 @@ function getChildInterruptPayload(context, options, execIndex) {
     return {
         arguments: [...(options.args || [])],
         await: options?.await ?? true,
-        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_MESHFLOW_EXP_BACKOFF,
+        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_MEMFLOW_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),
+        maximumAttempts: options?.config?.maximumAttempts ?? common_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
+        maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MEMFLOW_MAX_INTERVAL),
         originJobId: originJobId ?? workflowId,
         expire: options.expire ?? expire,
         persistent: options.persistent,
@@ -59,17 +59,17 @@ async function execChild(options) {
                 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);
+                if (code === common_1.HMSH_CODE_MEMFLOW_FATAL) {
+                    throw new common_1.MemFlowFatalError(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_MEMFLOW_MAXED) {
+                    throw new common_1.MemFlowMaxedError(message, stack);
                 }
-                else if (code === common_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
-                    throw new common_1.MeshFlowTimeoutError(message, stack);
+                else if (code === common_1.HMSH_CODE_MEMFLOW_TIMEOUT) {
+                    throw new common_1.MemFlowTimeoutError(message, stack);
                 }
                 else {
-                    throw new common_1.MeshFlowRetryError(message, stack);
+                    throw new common_1.MemFlowRetryError(message, stack);
                 }
             }
             return result.$error;
@@ -80,11 +80,11 @@ async function execChild(options) {
     }
     const interruptionMessage = getChildInterruptPayload(context, options, execIndex);
     interruptionRegistry.push({
-        code: common_1.HMSH_CODE_MESHFLOW_CHILD,
+        code: common_1.HMSH_CODE_MEMFLOW_CHILD,
         ...interruptionMessage,
     });
     await (0, common_1.sleepImmediate)();
-    throw new common_1.MeshFlowChildError(interruptionMessage);
+    throw new common_1.MemFlowChildError(interruptionMessage);
 }
 exports.execChild = execChild;
 /**

package/build/services/memflow/workflow/execHook.d.ts

@@ -0,0 +1,65 @@
+import { HookOptions } from './common';
+/**
+ * Extended hook options that include signal configuration
+ */
+export interface ExecHookOptions extends HookOptions {
+    /** Signal ID to send after hook execution */
+    signalId: string;
+}
+/**
+ * Executes a hook function and awaits the signal response.
+ * This is a convenience method that combines `hook()` and `waitFor()` operations.
+ *
+ * **Signal Injection**: The `signalId` is automatically injected as the LAST argument
+ * to the hooked function. The hooked function should check for this signal parameter
+ * and emit the signal when processing is complete.
+ *
+ * This behaves like `execChild` but targets the existing workflow instead of
+ * spawning a new workflow.
+ *
+ * @template T
+ * @param {ExecHookOptions} options - Hook configuration with signal ID.
+ * @returns {Promise<T>} The signal result from the hooked function.
+ *
+ * @example
+ * ```typescript
+ * // Execute a hook and await its signal response
+ * const result = await MemFlow.workflow.execHook({
+ *   taskQueue: 'processing',
+ *   workflowName: 'processData',
+ *   args: ['user123', 'batch-process'],
+ *   signalId: 'processing-complete'
+ * });
+ *
+ * // The hooked function receives the signal as the last argument:
+ * export async function processData(userId: string, processType: string, signalInfo?: { signal: string }) {
+ *   // ... do processing work ...
+ *   const result = { userId, processType, status: 'completed' };
+ *
+ *   // Check if called via execHook (signalInfo will be present)
+ *   if (signalInfo?.signal) {
+ *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Alternative pattern - check if last arg is signal object
+ * export async function myHookFunction(arg1: string, arg2: number, ...rest: any[]) {
+ *   // ... process arg1 and arg2 ...
+ *   const result = { processed: true, data: [arg1, arg2] };
+ *
+ *   // Check if last argument is a signal object
+ *   const lastArg = rest[rest.length - 1];
+ *   if (lastArg && typeof lastArg === 'object' && lastArg.signal) {
+ *     await MemFlow.workflow.signal(lastArg.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ */
+export declare function execHook<T>(options: ExecHookOptions): Promise<T>;

package/build/services/memflow/workflow/execHook.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHook = void 0;
+const hook_1 = require("./hook");
+const waitFor_1 = require("./waitFor");
+/**
+ * Executes a hook function and awaits the signal response.
+ * This is a convenience method that combines `hook()` and `waitFor()` operations.
+ *
+ * **Signal Injection**: The `signalId` is automatically injected as the LAST argument
+ * to the hooked function. The hooked function should check for this signal parameter
+ * and emit the signal when processing is complete.
+ *
+ * This behaves like `execChild` but targets the existing workflow instead of
+ * spawning a new workflow.
+ *
+ * @template T
+ * @param {ExecHookOptions} options - Hook configuration with signal ID.
+ * @returns {Promise<T>} The signal result from the hooked function.
+ *
+ * @example
+ * ```typescript
+ * // Execute a hook and await its signal response
+ * const result = await MemFlow.workflow.execHook({
+ *   taskQueue: 'processing',
+ *   workflowName: 'processData',
+ *   args: ['user123', 'batch-process'],
+ *   signalId: 'processing-complete'
+ * });
+ *
+ * // The hooked function receives the signal as the last argument:
+ * export async function processData(userId: string, processType: string, signalInfo?: { signal: string }) {
+ *   // ... do processing work ...
+ *   const result = { userId, processType, status: 'completed' };
+ *
+ *   // Check if called via execHook (signalInfo will be present)
+ *   if (signalInfo?.signal) {
+ *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Alternative pattern - check if last arg is signal object
+ * export async function myHookFunction(arg1: string, arg2: number, ...rest: any[]) {
+ *   // ... process arg1 and arg2 ...
+ *   const result = { processed: true, data: [arg1, arg2] };
+ *
+ *   // Check if last argument is a signal object
+ *   const lastArg = rest[rest.length - 1];
+ *   if (lastArg && typeof lastArg === 'object' && lastArg.signal) {
+ *     await MemFlow.workflow.signal(lastArg.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ */
+async function execHook(options) {
+    // Create hook options with signal field added to args
+    const hookOptions = {
+        ...options,
+        args: [...options.args, { signal: options.signalId }]
+    };
+    // Execute the hook with the signal information
+    await (0, hook_1.hook)(hookOptions);
+    // Wait for the signal response and return it
+    return await (0, waitFor_1.waitFor)(options.signalId);
+}
+exports.execHook = execHook;

package/build/services/{meshflow → memflow}/workflow/hook.js

@@ -26,13 +26,29 @@ async function hook(options) {
         else {
             targetTopic = workflowTopic;
         }
+        // DEFENSIVE CHECK: Prevent infinite loops
+        if (targetTopic === workflowTopic && !options.entity && !options.taskQueue) {
+            throw new Error(`MemFlow Hook Error: Potential infinite loop detected!\n\n` +
+                `The hook would target the same workflow topic ('${workflowTopic}') as the current workflow, ` +
+                `creating an infinite loop.\n\n` +
+                `To fix this, provide either:\n` +
+                `1. 'taskQueue' parameter: MemFlow.workflow.hook({ taskQueue: 'your-queue', workflowName: '${options.workflowName}', args: [...] })\n` +
+                `2. 'entity' parameter: MemFlow.workflow.hook({ entity: 'your-entity', args: [...] })\n\n` +
+                `Current workflow topic: ${workflowTopic}\n` +
+                `Target topic would be: ${targetTopic}\n` +
+                `Provided options: ${JSON.stringify({
+                    workflowName: options.workflowName,
+                    taskQueue: options.taskQueue,
+                    entity: options.entity
+                }, null, 2)}`);
+        }
         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),
+            backoffCoefficient: options.config?.backoffCoefficient || common_1.HMSH_MEMFLOW_EXP_BACKOFF,
+            maximumAttempts: options.config?.maximumAttempts || common_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
+            maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MEMFLOW_MAX_INTERVAL),
         };
         return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, common_1.StreamStatus.PENDING, 202);
     }

package/build/services/{meshflow → memflow}/workflow/index.d.ts

@@ -5,6 +5,7 @@ import { trace } from './trace';
 import { enrich } from './enrich';
 import { emit } from './emit';
 import { execChild, startChild } from './execChild';
+import { execHook } from './execHook';
 import { proxyActivities } from './proxyActivities';
 import { search } from './searchMethods';
 import { random } from './random';
@@ -15,6 +16,7 @@ import { all } from './all';
 import { sleepFor } from './sleepFor';
 import { waitFor } from './waitFor';
 import { HotMesh } from './common';
+import { context } from './contextMethods';
 /**
  * The WorkflowService class provides a set of static methods to be used within a workflow function.
  * These methods ensure deterministic replay, persistence of state, and error handling across
@@ -26,12 +28,12 @@ import { HotMesh } from './common';
  *
  * @example
  * ```typescript
- * import { MeshFlow } from '@hotmeshio/hotmesh';
+ * import { MemFlow } from '@hotmeshio/hotmesh';
  *
  * export async function waitForExample(): Promise<[boolean, number]> {
  *   const [s1, s2] = await Promise.all([
- *     MeshFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
- *     MeshFlow.workflow.waitFor<number>('my-sig-nal-2')
+ *     MemFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
+ *     MemFlow.workflow.waitFor<number>('my-sig-nal-2')
  *   ]);
  *   return [s1, s2];
  * }
@@ -53,8 +55,10 @@ export declare class WorkflowService {
     static execChild: typeof execChild;
     static executeChild: typeof execChild;
     static startChild: typeof startChild;
+    static execHook: typeof execHook;
     static proxyActivities: typeof proxyActivities;
     static search: typeof search;
+    static context: typeof context;
     static random: typeof random;
     static signal: typeof signal;
     static hook: typeof hook;

package/build/services/{meshflow → memflow}/workflow/index.js

@@ -8,6 +8,7 @@ const trace_1 = require("./trace");
 const enrich_1 = require("./enrich");
 const emit_1 = require("./emit");
 const execChild_1 = require("./execChild");
+const execHook_1 = require("./execHook");
 const proxyActivities_1 = require("./proxyActivities");
 const searchMethods_1 = require("./searchMethods");
 const random_1 = require("./random");
@@ -18,6 +19,7 @@ const all_1 = require("./all");
 const sleepFor_1 = require("./sleepFor");
 const waitFor_1 = require("./waitFor");
 const common_1 = require("./common");
+const contextMethods_1 = require("./contextMethods");
 /**
  * The WorkflowService class provides a set of static methods to be used within a workflow function.
  * These methods ensure deterministic replay, persistence of state, and error handling across
@@ -29,12 +31,12 @@ const common_1 = require("./common");
  *
  * @example
  * ```typescript
- * import { MeshFlow } from '@hotmeshio/hotmesh';
+ * import { MemFlow } from '@hotmeshio/hotmesh';
  *
  * export async function waitForExample(): Promise<[boolean, number]> {
  *   const [s1, s2] = await Promise.all([
- *     MeshFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
- *     MeshFlow.workflow.waitFor<number>('my-sig-nal-2')
+ *     MemFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
+ *     MemFlow.workflow.waitFor<number>('my-sig-nal-2')
  *   ]);
  *   return [s1, s2];
  * }
@@ -71,8 +73,10 @@ WorkflowService.emit = emit_1.emit;
 WorkflowService.execChild = execChild_1.execChild;
 WorkflowService.executeChild = execChild_1.executeChild;
 WorkflowService.startChild = execChild_1.startChild;
+WorkflowService.execHook = execHook_1.execHook;
 WorkflowService.proxyActivities = proxyActivities_1.proxyActivities;
 WorkflowService.search = searchMethods_1.search;
+WorkflowService.context = contextMethods_1.context;
 WorkflowService.random = random_1.random;
 WorkflowService.signal = signal_1.signal;
 WorkflowService.hook = hook_1.hook;

package/build/services/{meshflow → memflow}/workflow/proxyActivities.d.ts

@@ -1,10 +1,10 @@
-import { ActivityConfig, ProxyType, MeshFlowProxyErrorType } from './common';
+import { ActivityConfig, ProxyType, MemFlowProxyErrorType } from './common';
 import { getContext } from './context';
 /**
  * Constructs payload for spawning a proxyActivity job.
  * @private
  */
-declare function getProxyInterruptPayload(context: ReturnType<typeof getContext>, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): MeshFlowProxyErrorType;
+declare function getProxyInterruptPayload(context: ReturnType<typeof getContext>, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): MemFlowProxyErrorType;
 /**
  * Wraps a single activity in a proxy, orchestrating its execution and replay.
  * @private