@hotmeshio/hotmesh 0.1.6 → 0.1.8

package/README.md

@@ -295,31 +295,31 @@ const hotMesh = await HotMesh.init({
 ```
 
 ### Observability
-Workflows and activities are run according to the rules you define, offering [Graph-Oriented](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md#telemetry) telemetry insights into your legacy function executions.
+Workflows and activities are run according to the rules you define, offering [Graph-Oriented](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/system_lifecycle.md#telemetry) telemetry insights into your legacy function executions.
 
 ## FAQ
-Refer to the [FAQ](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md) for terminology, definitions, and an exploration of how HotMesh facilitates orchestration use cases.
+Refer to the [FAQ](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/faq.md) for terminology, definitions, and an exploration of how HotMesh facilitates orchestration use cases.
 
 ## Quick Start
-Refer to the [Quick Start](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/quickstart.md) for sample YAML workflows you can copy, paste, and modify to get started.
+Refer to the [Quick Start](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/quickstart.md) for sample YAML workflows you can copy, paste, and modify to get started.
 
 ## Developer Guide
-For more details on the complete development process, including information about schemas, APIs, and deployment, consult the [Developer Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/developer_guide.md).
+For more details on the complete development process, including information about schemas, APIs, and deployment, consult the [Developer Guide](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/developer_guide.md).
 
 ## Model Driven Development
-[Model Driven Development](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/model_driven_development.md) is an established strategy for managing process-oriented tasks. Check out this guide to understand its foundational principles.
+[Model Driven Development](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/model_driven_development.md) is an established strategy for managing process-oriented tasks. Check out this guide to understand its foundational principles.
 
 ## Data Mapping
-Exchanging data between activities is central to HotMesh. For detailed information on supported functions and the functional mapping syntax (@pipes), see the [Data Mapping Overview](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/data_mapping.md).
+Exchanging data between activities is central to HotMesh. For detailed information on supported functions and the functional mapping syntax (@pipes), see the [Data Mapping Overview](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/data_mapping.md).
 
 ## Composition
-While the simplest graphs are linear, detailing a consistent sequence of non-cyclical activities, graphs can be layered to represent intricate business scenarios. Some can even be designed to accommodate long-lasting workflows that span months. For more details, check out the [Composable Workflow Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/composable_workflow.md).
+While the simplest graphs are linear, detailing a consistent sequence of non-cyclical activities, graphs can be layered to represent intricate business scenarios. Some can even be designed to accommodate long-lasting workflows that span months. For more details, check out the [Composable Workflow Guide](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/composable_workflow.md).
 
 ## System Lifecycle
-Gain insight into HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/system_lifecycle.md).
+Gain insight into HotMesh's monitoring, exception handling, and alarm configurations via the [System Lifecycle Guide](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/system_lifecycle.md).
 
 ## Distributed Orchestration | System Overview
-HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchestration Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md) for a high-level overview of the approach.
+HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchestration Guide](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/distributed_orchestration.md) for a high-level overview of the approach.
 
 ## Distributed Orchestration | System Design
 HotMesh is more than Redis and TypeScript. The theory that underlies the architecture is applicable to any number of data storage and streaming backends: [A Message-Oriented Approach to Decentralized Process Orchestration](https://zenodo.org/records/12168558).

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -41,7 +41,7 @@
         "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:expired": "NODE_ENV=test jest ./tests/functional/expired/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:pending": "NODE_ENV=test jest ./tests/functional/pending/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
         "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",

package/build/services/activities/trigger.js

@@ -25,16 +25,16 @@ class Trigger extends activity_1.Activity {
             telemetry.startJobSpan();
             telemetry.startActivitySpan(this.leg);
             this.mapJobData();
-            await this.setStateNX(options?.expired ? -1 : undefined);
+            await this.setStateNX(options?.pending ? -1 : undefined);
             this.adjacencyList = await this.filterAdjacent();
-            await this.setStatus(options?.expired ? -1 : this.adjacencyList.length);
+            await this.setStatus(options?.pending ? -1 : this.adjacencyList.length);
             this.bindSearchData(options);
             this.bindMarkerData(options);
             const multi = this.store.getMulti();
             await this.setState(multi);
             await this.setStats(multi);
-            if (options?.expired) {
-                await this.setExpired(options?.expired, multi);
+            if (options?.pending) {
+                await this.setExpired(options?.pending, multi);
             }
             else {
                 await this.registerJobDependency(multi);
@@ -47,8 +47,7 @@ class Trigger extends activity_1.Activity {
             const jobStatus = Number(this.context.metadata.js);
             telemetry.setJobAttributes({ 'app.job.jss': jobStatus });
             const attrs = { 'app.job.jss': jobStatus };
-            //only transition if not inited in an expired state
-            //todo: enable resume from expired state
+            //todo: enable resume from pending state
             if (jobStatus !== -1) {
                 const messageIds = await this.transition(this.adjacencyList, jobStatus);
                 if (messageIds.length) {

package/build/services/durable/client.js

@@ -19,10 +19,11 @@ class ClientService {
         this.getHotMeshClient = async (workflowTopic, namespace) => {
             const targetNS = namespace ?? factory_1.APP_ID;
             if (ClientService.instances.has(targetNS)) {
+                const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
                 const hotMeshClient = await ClientService.instances.get(targetNS);
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
-                if (!ClientService.topics.includes(workflowTopic)) {
-                    ClientService.topics.push(workflowTopic);
+                if (!ClientService.topics.includes(targetTopic)) {
+                    ClientService.topics.push(targetTopic);
                     await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
                 }
                 return hotMeshClient;
@@ -76,7 +77,7 @@ class ClientService {
                 const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context, {
                     search: options?.search?.data,
                     marker: options?.marker,
-                    expired: options?.expired,
+                    pending: options?.pending,
                 });
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
@@ -205,11 +206,12 @@ ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) =>
  * exists and if not, create it.
  */
 ClientService.verifyStream = async (workflowTopic, namespace) => {
+    const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
     const targetNS = namespace ?? factory_1.APP_ID;
     if (ClientService.instances.has(targetNS)) {
         const hotMeshClient = await ClientService.instances.get(targetNS);
-        if (!ClientService.topics.includes(workflowTopic)) {
-            ClientService.topics.push(workflowTopic);
+        if (!ClientService.topics.includes(targetTopic)) {
+            ClientService.topics.push(targetTopic);
             await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
         }
         return hotMeshClient;

package/build/services/durable/exporter.js

@@ -40,23 +40,23 @@ class ExporterService {
                 //transitions
                 this.inflateTransition(match, value, transitionsObject);
             }
-            else if (key.length === 3) {
-                //state
-                state[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
-            }
             else if (key.startsWith('_')) {
                 //data
                 data[key.substring(1)] = value;
             }
             else if (key.startsWith('-')) {
                 //timeline
-                const keyParts = this.keyToObject(key); //key parts have meaning
+                const keyParts = this.keyToObject(key);
                 timeline.push({
                     ...keyParts,
                     key,
                     value: this.resolveValue(value, options.values),
                 });
             }
+            else if (key.length === 3) {
+                //state
+                state[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
+            }
         });
         return this.filterFields({
             data: (0, utils_1.restoreHierarchy)(data),

package/build/services/durable/worker.d.ts

@@ -2,11 +2,12 @@ import { HotMeshService as HotMesh } from '../hotmesh';
 import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
 export declare class WorkerService {
     static activityRegistry: Registry;
-    static connection: Connection;
+    static connections: Map<string, import("../../types/durable").ConnectionConfig>;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     workflowRunner: HotMesh;
     activityRunner: HotMesh;
     static getHotMesh: (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => Promise<HotMesh>;
+    static findConnectionByNamespace: (namespace: string) => Connection;
     static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     static registerActivities<ACT>(activities: ACT): Registry;
     static create(config: WorkerConfig): Promise<WorkerService>;

package/build/services/durable/worker.js

@@ -58,7 +58,8 @@ class WorkerService {
         return WorkerService.activityRegistry;
     }
     static async create(config) {
-        WorkerService.connection = config.connection;
+        const targetNamespace = config.namespace ?? factory_1.APP_ID;
+        WorkerService.connections.set(targetNamespace, config.connection);
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
@@ -371,20 +372,37 @@ class WorkerService {
 }
 _a = WorkerService;
 WorkerService.activityRegistry = {}; //user's activities
+WorkerService.connections = new Map();
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
-    if (WorkerService.instances.has(workflowTopic)) {
-        return await WorkerService.instances.get(workflowTopic);
+    const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+    const targetTopic = `${targetNamespace}.${workflowTopic}`;
+    if (WorkerService.instances.has(targetTopic)) {
+        return await WorkerService.instances.get(targetTopic);
     }
     const hotMeshClient = hotmesh_1.HotMeshService.init({
         logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-        appId: config.namespace ?? factory_1.APP_ID,
-        engine: { redis: { ...WorkerService.connection } },
+        appId: targetNamespace,
+        engine: {
+            redis: { ...WorkerService.findConnectionByNamespace(targetNamespace) },
+        },
     });
-    WorkerService.instances.set(workflowTopic, hotMeshClient);
+    WorkerService.instances.set(targetTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
 };
+WorkerService.findConnectionByNamespace = (namespace) => {
+    let defaultConnection;
+    for (const [ns, value] of WorkerService.connections) {
+        if (ns === namespace) {
+            return value;
+        }
+        else if (!defaultConnection) {
+            defaultConnection = value;
+        }
+    }
+    return defaultConnection;
+};
 WorkerService.Context = {
     info: () => {
         return {

package/build/types/durable.d.ts

@@ -261,16 +261,16 @@ type WorkflowOptions = {
      */
     await?: boolean;
     /**
-     * If provided, the job will initialize in an expired state, reserving
+     * If provided, the job will initialize in a pending state, reserving
      * only the job ID (HSETNX) and persisting search and marker (if provided).
      * If a `resume` signal is sent before the specified number of seconds,
-     * the job will resume as normal, transition to the adjacent children
+     * the job will resume as normal, transitioning to the adjacent children
      * of the trigger. If the job is not resumed within the number
      * of seconds specified, the job will be scrubbed. No dependencies
-     * are added for a job in an expired state; however, dependencies
+     * are added for a job in a pending state; however, dependencies
      * will be added after the job is resumed if relevant.
      */
-    expired?: number;
+    pending?: number;
 };
 /**
  * Options for setting up a hook.

package/build/types/index.d.ts

@@ -7,7 +7,7 @@ export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConf
 export { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType, } from './error';
 export { ActivityAction, DependencyExport, DurableJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline, } from './exporter';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal, } from './hook';
-export { ILogger } from './logger';
+export { ILogger, LogLevel, } from './logger';
 export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, } from './job';
 export { MappingStatements } from './map';
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject, } from './pipe';

package/build/types/job.d.ts

@@ -78,16 +78,16 @@ type ExtensionType = {
      */
     marker?: StringStringType;
     /**
-     * If provided, the job will initialize in an expired state, reserving
+     * If provided, the job will initialize in a pending state, reserving
      * only the job ID (HSETNX) and persisting search and marker (if provided).
      * If a `resume` signal is sent before the specified number of seconds,
-     * the job will resume as normal, transition the the adjacent children
-     * of the trigger. If the job is not resumed within the
-     * number of seconds specified, the job will be scrubbed. No dependencies
-     * are added for a job in an expired state; however, dependencies will be
-     * added after the job is resumed if relevant.
+     * the job will resume as normal, transitioning to the adjacent children
+     * of the trigger. If the job is not resumed within the number
+     * of seconds specified, the job will be scrubbed. No dependencies
+     * are added for a job in a pending state; however, dependencies
+     * will be added after the job is resumed if relevant.
      */
-    expired?: number;
+    pending?: number;
 };
 /**
  * job_status semaphore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -41,7 +41,7 @@
     "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:expired": "NODE_ENV=test jest ./tests/functional/expired/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:pending": "NODE_ENV=test jest ./tests/functional/pending/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
     "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",

package/types/durable.ts

@@ -315,16 +315,16 @@ type WorkflowOptions = {
   await?: boolean;
 
   /**
-   * If provided, the job will initialize in an expired state, reserving
+   * If provided, the job will initialize in a pending state, reserving
    * only the job ID (HSETNX) and persisting search and marker (if provided).
    * If a `resume` signal is sent before the specified number of seconds,
-   * the job will resume as normal, transition to the adjacent children
+   * the job will resume as normal, transitioning to the adjacent children
    * of the trigger. If the job is not resumed within the number
    * of seconds specified, the job will be scrubbed. No dependencies
-   * are added for a job in an expired state; however, dependencies
+   * are added for a job in a pending state; however, dependencies
    * will be added after the job is resumed if relevant.
    */
-  expired?: number;
+  pending?: number;
 };
 
 /**

package/types/index.ts

@@ -77,7 +77,10 @@ export {
   HookRules,
   HookSignal,
 } from './hook';
-export { ILogger } from './logger';
+export {
+  ILogger,
+  LogLevel,
+} from './logger';
 export {
   ExtensionType,
   JobCompletionOptions,

package/types/job.ts

@@ -108,16 +108,16 @@ type ExtensionType = {
   marker?: StringStringType;
 
   /**
-   * If provided, the job will initialize in an expired state, reserving
+   * If provided, the job will initialize in a pending state, reserving
    * only the job ID (HSETNX) and persisting search and marker (if provided).
    * If a `resume` signal is sent before the specified number of seconds,
-   * the job will resume as normal, transition the the adjacent children
-   * of the trigger. If the job is not resumed within the
-   * number of seconds specified, the job will be scrubbed. No dependencies
-   * are added for a job in an expired state; however, dependencies will be
-   * added after the job is resumed if relevant.
+   * the job will resume as normal, transitioning to the adjacent children
+   * of the trigger. If the job is not resumed within the number
+   * of seconds specified, the job will be scrubbed. No dependencies
+   * are added for a job in a pending state; however, dependencies
+   * will be added after the job is resumed if relevant.
    */
-  expired?: number;
+  pending?: number;
 };
 
 /**