@hotmeshio/hotmesh 0.0.20 → 0.0.22

package/README.md

@@ -226,9 +226,6 @@ Exchanging data between activities is central to HotMesh. For detailed informati
 ## 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).
 
-## Architectural First Principles
-For a deep dive into HotMesh's distributed orchestration philosophy, refer to the [Architectural First Principles Overview](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/architecture.md).
-
 ## Distributed Orchestration
 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 detailed breakdown of the approach.
 

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.20",
+    "version": "0.0.22",
     "description": "Unbreakable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",

package/build/services/durable/search.js

@@ -12,10 +12,9 @@ class Search {
         this.searchSessionIndex = 0;
         const keyParams = {
             appId: hotMeshClient.appId,
-            jobId: ''
+            jobId: workflowId
         };
-        const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        this.jobId = `${hotMeshPrefix}${workflowId}`;
+        this.jobId = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
         this.searchSessionId = searchSessionId;
         this.hotMeshClient = hotMeshClient;
         this.store = hotMeshClient.engine.store;

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

@@ -3,9 +3,13 @@ import { HotMeshService as HotMesh } from '../hotmesh';
 import { ActivityConfig, HookOptions, ProxyType, WorkflowOptions } from "../../types/durable";
 export declare class WorkflowService {
     /**
-     * Spawn a child workflow. await the result.
+     * Spawn a child workflow. await and return the result.
      */
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
+    /**
+     * spawn a child workflow. return the childJobId.
+     */
+    static startChild<T>(options: WorkflowOptions): Promise<string>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
     static search(): Promise<Search>;
     /**

package/build/services/durable/workflow.js

@@ -16,37 +16,79 @@ const worker_1 = require("./worker");
 const stream_1 = require("../../types/stream");
 class WorkflowService {
     /**
-     * Spawn a child workflow. await the result.
+     * Spawn a child workflow. await and return the result.
      */
     static async executeChild(options) {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const namespace = store.get('namespace');
         const workflowId = store.get('workflowId');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTrace = store.get('workflowTrace');
         const workflowSpan = store.get('workflowSpan');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const childJobId = `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+        //this is risky but MUST be allowed. Users MAY set the workflowId,
+        //but if there is a naming collision, the data from the target entity will be used
+        //as there is know way of knowing if the item was generated via a prior run of the workflow
+        const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
         const parentWorkflowId = `${workflowId}-f`;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
-        let handle = await client.workflow.getHandle(options.taskQueue, options.workflowName, childJobId);
+        let handle = await client.workflow.getHandle(options.taskQueue, options.workflowName, childJobId, namespace);
         try {
             return await handle.result(true);
         }
         catch (error) {
             handle = await client.workflow.start({
                 ...options,
+                namespace,
                 workflowId: childJobId,
                 parentWorkflowId,
                 workflowTrace,
                 workflowSpan,
             });
+            //todo: options.startToCloseTimeout
             const result = await handle.result();
             return result;
         }
     }
+    /**
+     * spawn a child workflow. return the childJobId.
+     */
+    static async startChild(options) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const namespace = store.get('namespace');
+        const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const workflowTrace = store.get('workflowTrace');
+        const workflowSpan = store.get('workflowSpan');
+        const COUNTER = store.get('counter');
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+        const parentWorkflowId = `${workflowId}-f`;
+        const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+        try {
+            //get the status; if there is no error, return childJobId (what was spawned)
+            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+            await hotMeshClient.getStatus(childJobId);
+            return childJobId;
+        }
+        catch (error) {
+            const client = new client_1.ClientService({
+                connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
+            });
+            await client.workflow.start({
+                ...options,
+                namespace,
+                workflowId: childJobId,
+                parentWorkflowId,
+                workflowTrace,
+                workflowSpan,
+            });
+            return childJobId;
+        }
+    }
     static proxyActivities(options) {
         if (options.activities) {
             worker_1.WorkerService.registerActivities(options.activities);
@@ -119,16 +161,11 @@ class WorkflowService {
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
             const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
-            let workflowId;
-            let workflowTopic;
-            if (options.workflowId && options.taskQueue && options.workflowName) {
-                workflowId = options.workflowId;
+            const workflowId = options.workflowId ?? store.get('workflowId');
+            let workflowTopic = store.get('workflowTopic');
+            if (options.taskQueue && options.workflowName) {
                 workflowTopic = `${options.taskQueue}-${options.workflowName}`;
-            }
-            else {
-                workflowId = store.get('workflowId');
-                workflowTopic = store.get('workflowTopic');
-            }
+            } //else this is essentially recursion as the function calls itself
             const payload = {
                 arguments: [...options.args],
                 id: workflowId,

package/build/types/durable.d.ts

@@ -18,7 +18,7 @@ type WorkflowOptions = {
     namespace?: string;
     taskQueue: string;
     args: any[];
-    workflowId: string;
+    workflowId?: string;
     workflowName?: string;
     parentWorkflowId?: string;
     workflowTrace?: string;
@@ -28,9 +28,9 @@ type WorkflowOptions = {
 };
 type HookOptions = {
     namespace?: string;
-    taskQueue: string;
+    taskQueue?: string;
     args: any[];
-    workflowId: string;
+    workflowId?: string;
     workflowName?: string;
     search?: WorkflowSearchOptions;
     config?: WorkflowConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/services/durable/search.ts

@@ -19,10 +19,9 @@ export class Search {
   constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string) {
     const keyParams = {
       appId: hotMeshClient.appId,
-      jobId: ''
+      jobId: workflowId
     }
-    const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
-    this.jobId = `${hotMeshPrefix}${workflowId}`;
+    this.jobId = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
     this.searchSessionId = searchSessionId;
     this.hotMeshClient = hotMeshClient;
     this.store = hotMeshClient.engine.store as StoreService<RedisClient, RedisMulti>;

package/services/durable/workflow.ts

@@ -23,17 +23,21 @@ import { StreamStatus } from '../../types/stream';
 export class WorkflowService {
 
   /**
-   * Spawn a child workflow. await the result.
+   * Spawn a child workflow. await and return the result.
    */
   static async executeChild<T>(options: WorkflowOptions): Promise<T> {
     const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
     const workflowId = store.get('workflowId');
     const workflowDimension = store.get('workflowDimension') ?? '';
     const workflowTrace = store.get('workflowTrace');
     const workflowSpan = store.get('workflowSpan');
     const COUNTER = store.get('counter');
     const execIndex = COUNTER.counter = COUNTER.counter + 1;
-    const childJobId = `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+    //this is risky but MUST be allowed. Users MAY set the workflowId,
+    //but if there is a naming collision, the data from the target entity will be used
+    //as there is know way of knowing if the item was generated via a prior run of the workflow
+    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
     const parentWorkflowId = `${workflowId}-f`;
 
     const client = new Client({
@@ -43,7 +47,8 @@ export class WorkflowService {
     let handle = await client.workflow.getHandle(
       options.taskQueue,
       options.workflowName,
-      childJobId
+      childJobId,
+      namespace,
     );
 
     try {
@@ -51,16 +56,56 @@ export class WorkflowService {
     } catch (error) {
       handle = await client.workflow.start({
         ...options,
+        namespace,
         workflowId: childJobId,
         parentWorkflowId,
         workflowTrace,
         workflowSpan,
       });
+      //todo: options.startToCloseTimeout
       const result = await handle.result();
       return result as T;
     }
   }
 
+  /**
+   * spawn a child workflow. return the childJobId.
+   */
+  static async startChild<T>(options: WorkflowOptions): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const workflowTrace = store.get('workflowTrace');
+    const workflowSpan = store.get('workflowSpan');
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+    const parentWorkflowId = `${workflowId}-f`;
+    const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+
+    try {
+      //get the status; if there is no error, return childJobId (what was spawned)
+      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
+      await hotMeshClient.getStatus(childJobId);
+      return childJobId;
+    } catch (error) {
+      const client = new Client({
+        connection: await Connection.connect(WorkerService.connection),
+      });
+  
+      await client.workflow.start({
+        ...options,
+        namespace,
+        workflowId: childJobId,
+        parentWorkflowId,
+        workflowTrace,
+        workflowSpan,
+      });
+      return childJobId;
+    }
+  }
+
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
     if (options.activities) {
       WorkerService.registerActivities(options.activities)
@@ -138,15 +183,11 @@ export class WorkflowService {
     const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
     if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
       const store = asyncLocalStorage.getStore();
-      let workflowId: string;
-      let workflowTopic: string;
-      if (options.workflowId && options.taskQueue && options.workflowName) {
-        workflowId = options.workflowId;
+      const workflowId = options.workflowId ?? store.get('workflowId');
+      let workflowTopic = store.get('workflowTopic');
+      if (options.taskQueue && options.workflowName) {
         workflowTopic = `${options.taskQueue}-${options.workflowName}`;
-      } else {
-        workflowId = store.get('workflowId');
-        workflowTopic = store.get('workflowTopic');
-      }
+      } //else this is essentially recursion as the function calls itself
       const payload = {
         arguments: [...options.args],
         id: workflowId,

package/types/durable.ts

@@ -18,7 +18,7 @@ type WorkflowOptions = {
   namespace?: string;   //'durable' is the default namespace if not provided; similar to setting `appid` in the YAML
   taskQueue: string;
   args: any[];          //input arguments to pass in
-  workflowId: string;   //execution id (the job id)
+  workflowId?: string;   //execution id (the job id)
   workflowName?: string; //the name of the user's workflow function
   parentWorkflowId?: string;  //system reserved; the id of the parent; if present the flow will not self-clean until the parent that spawned it self-cleans
   workflowTrace?: string;
@@ -29,9 +29,9 @@ type WorkflowOptions = {
 
 type HookOptions = {
   namespace?: string;   //'durable' is the default namespace if not provided; similar to setting `appid` in the YAML
-  taskQueue: string;
+  taskQueue?: string;
   args: any[];          //input arguments to pass into the hook
-  workflowId: string;   //execution id (the job id to hook into)
+  workflowId?: string;   //execution id (the job id to hook into)
   workflowName?: string; //the name of the user's hook function
   search?: WorkflowSearchOptions //bind additional search terms immediately before hook reentry
   config?: WorkflowConfig; //hook function constraints (backoffCoefficient, maximumAttempts, maximumInterval, initialInterval)