@hotmeshio/hotmesh 0.0.14 → 0.0.16

package/README.md

@@ -22,7 +22,7 @@ The HotMesh SDK is designed to keep your code front-and-center. Write functions
     }
 
     export async function saludar(nombre: string): Promise<string> {
-      Math.random() > 0.5 && throw new Error('Random error');
+      if (Math.random() > 0.5) throw new Error('Random error');
       return `¡Hola, ${nombre}!`;
     }
     ```

package/build/package.json

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

package/build/services/activities/activity.js

@@ -136,10 +136,10 @@ class Activity {
         try {
             this.setLeg(2);
             await this.getState(jobId);
-            const aState = await collator_1.CollatorService.notarizeReentry(this);
-            this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
+            const aState = await collator_1.CollatorService.notarizeReentry(this);
+            this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
             this.bindActivityData('hook');
             this.mapJobData();
             this.adjacencyList = await this.filterAdjacent();
@@ -159,6 +159,10 @@ class Activity {
             return jobStatus;
         }
         catch (error) {
+            if (error instanceof errors_1.CollationError && error.fault === 'inactive') {
+                this.logger.info('process-hook-event-inactive-error', { error });
+                return;
+            }
             this.logger.error('engine-process-hook-event-error', { error });
             telemetry.setActivityError(error.message);
             throw error;
@@ -201,6 +205,10 @@ class Activity {
             this.transitionAdjacent(multiResponse, telemetry);
         }
         catch (error) {
+            if (error instanceof errors_1.CollationError && error.fault === 'inactive') {
+                this.logger.info('process-event-inactive-error', { error });
+                return;
+            }
             this.logger.error('activity-process-event-error', { error });
             telemetry && telemetry.setActivityError(error.message);
             throw error;

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

@@ -10,6 +10,7 @@ export declare class ClientService {
     workflow: {
         start: (options: WorkflowOptions) => Promise<WorkflowHandleService>;
         signal: (signalId: string, data: Record<any, any>) => Promise<string>;
+        getHandle: (taskQueue: string, workflowName: string, workflowId: string) => Promise<WorkflowHandleService>;
     };
     activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
     static shutdown(): Promise<void>;

package/build/services/durable/client.js

@@ -97,6 +97,11 @@ class ClientService {
             },
             signal: async (signalId, data) => {
                 return await (await this.getHotMeshClient('durable.wfs.signal')).hook('durable.wfs.signal', { id: signalId, data });
+            },
+            getHandle: async (taskQueue, workflowName, workflowId) => {
+                const workflowTopic = `${taskQueue}-${workflowName}`;
+                const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+                return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
             }
         };
         this.connection = config.connection;

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

@@ -2,6 +2,11 @@
  * NOTE: Using `maxSystemRetries = 3` and `backoffCoefficient = 10`, errant
  *       workflows will be retried on the following schedule (8 times in 27 hours):
  *       => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ * 593:
+ * 594: waitforsignal
+ * 595: sleep
+ * 596, 597, 598: fatal
+ * 599: retry
  */
 declare const getWorkflowYAML: (app: string, version: string) => string;
 declare const APP_VERSION = "1";

package/build/services/durable/factory.js

@@ -3,6 +3,11 @@
  * NOTE: Using `maxSystemRetries = 3` and `backoffCoefficient = 10`, errant
  *       workflows will be retried on the following schedule (8 times in 27 hours):
  *       => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ * 593:
+ * 594: waitforsignal
+ * 595: sleep
+ * 596, 597, 598: fatal
+ * 599: retry
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WFS_HOOK_ID = exports.WFSC_PUBLISHES_TOPIC = exports.WFSC_SUBSCRIBES_TOPIC = exports.WFS_PUBLISHES_TOPIC = exports.WFS_SUBSCRIBES_TOPIC = exports.DEFAULT_COEFFICIENT = exports.SLEEP_HOOK_ID = exports.ACTIVITY_HOOK_ID = exports.HOOK_ID = exports.PUBLISHES_TOPIC = exports.SUBSCRIBES_TOPIC = exports.SLEEP_PUBLISHES_TOPIC = exports.SLEEP_SUBSCRIBES_TOPIC = exports.ACTIVITY_PUBLISHES_TOPIC = exports.ACTIVITY_SUBSCRIBES_TOPIC = exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;

package/build/services/durable/workflow.js

@@ -51,17 +51,26 @@ class WorkflowService {
         const workflowId = store.get('workflowId');
         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}-${execIndex}`;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
-        const handle = await client.workflow.start({
-            ...options,
-            workflowId: `${workflowId}${options.workflowId}`,
-            workflowTrace,
-            workflowSpan,
-        });
-        const result = await handle.result();
-        return result;
+        let handle = await client.workflow.getHandle(options.taskQueue, options.workflowName, childJobId);
+        try {
+            return await handle.result();
+        }
+        catch (error) {
+            handle = await client.workflow.start({
+                ...options,
+                workflowId: childJobId,
+                workflowTrace,
+                workflowSpan,
+            });
+            const result = await handle.result();
+            return result;
+        }
     }
     static proxyActivities(options) {
         if (options.activities) {
@@ -168,7 +177,7 @@ class WorkflowService {
             const trc = store.get('workflowTrace');
             const spn = store.get('workflowSpan');
             const activityTopic = `${workflowTopic}-activity`;
-            const activityJobId = `${workflowId}-${activityName}-${execIndex}`;
+            const activityJobId = `${workflowId}-$${activityName}-${execIndex}`;
             let activityState;
             try {
                 const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic);

package/build/services/store/index.js

@@ -373,6 +373,9 @@ class StoreService {
     async getStatus(jobId, appId) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
         const status = await this.redisClient[this.commands.hget](jobKey, ':');
+        if (status === null) {
+            throw new Error(`Job ${jobId} not found`);
+        }
         return Number(status);
     }
     async setState({ ...state }, status, jobId, symbolNames, dIds, multi) {

package/package.json

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

package/services/activities/activity.ts

@@ -1,4 +1,4 @@
-import { GetStateError } from '../../modules/errors';
+import { CollationError, GetStateError } from '../../modules/errors';
 import {
   formatISODate,
   getValueByPath,
@@ -183,11 +183,11 @@ class Activity {
     try {
       this.setLeg(2);
       await this.getState(jobId);
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      telemetry.startActivitySpan(this.leg);
       const aState = await CollatorService.notarizeReentry(this);
       this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
 
-      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-      telemetry.startActivitySpan(this.leg);
       this.bindActivityData('hook');
       this.mapJobData();
       this.adjacencyList = await this.filterAdjacent();
@@ -209,6 +209,10 @@ class Activity {
       telemetry.setActivityAttributes(attrs);
       return jobStatus as number;
     } catch (error) {
+      if (error instanceof CollationError && error.fault === 'inactive') {
+        this.logger.info('process-hook-event-inactive-error', { error });
+        return;
+      }
       this.logger.error('engine-process-hook-event-error', { error });
       telemetry.setActivityError(error.message);
       throw error;
@@ -251,6 +255,10 @@ class Activity {
       }
       this.transitionAdjacent(multiResponse, telemetry);
     } catch (error) {
+      if (error instanceof CollationError && error.fault === 'inactive') {
+        this.logger.info('process-event-inactive-error', { error });
+        return;
+      }
       this.logger.error('activity-process-event-error', { error });
       telemetry && telemetry.setActivityError(error.message);
       throw error;

package/services/durable/client.ts

@@ -115,6 +115,12 @@ export class ClientService {
 
     signal: async (signalId: string, data: Record<any, any>): Promise<string> => {
       return await (await this.getHotMeshClient('durable.wfs.signal')).hook('durable.wfs.signal', { id: signalId, data });
+    },
+
+    getHandle: async (taskQueue: string, workflowName: string, workflowId: string): Promise<WorkflowHandleService> => {
+      const workflowTopic = `${taskQueue}-${workflowName}`;
+      const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+      return new WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
     }
   }
 

package/services/durable/factory.ts

@@ -2,6 +2,11 @@
  * NOTE: Using `maxSystemRetries = 3` and `backoffCoefficient = 10`, errant
  *       workflows will be retried on the following schedule (8 times in 27 hours):
  *       => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ * 593: 
+ * 594: waitforsignal
+ * 595: sleep
+ * 596, 597, 598: fatal
+ * 599: retry
  */
 
 //todo: getChildWorkflowYAML (includes key, so flow will cleanup)

package/services/durable/workflow.ts

@@ -8,7 +8,6 @@ import { ActivityConfig, ProxyType, WorkflowOptions } from "../../types/durable"
 import { JobOutput, JobState } from '../../types';
 import { ACTIVITY_PUBLISHES_TOPIC, ACTIVITY_SUBSCRIBES_TOPIC, SLEEP_SUBSCRIBES_TOPIC, WFS_SUBSCRIBES_TOPIC } from './factory';
 import { DurableIncompleteSignalError, DurableSleepError, DurableWaitForSignalError } from '../../modules/errors';
-import { stringify } from 'querystring';
 
 /*
 `proxyActivities` returns a wrapped instance of the 
@@ -52,18 +51,32 @@ export class WorkflowService {
     const workflowId = store.get('workflowId');
     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}-${execIndex}`;
 
     const client = new Client({
       connection: await Connection.connect(WorkerService.connection),
     });
-    const handle = await client.workflow.start({
-      ...options,
-      workflowId: `${workflowId}${options.workflowId}`, //concat (caller MUST PROVIDE)
-      workflowTrace,
-      workflowSpan,
-    });
-    const result = await handle.result();
-    return result as T;
+
+    let handle = await client.workflow.getHandle(
+      options.taskQueue,
+      options.workflowName,
+      childJobId
+    );
+
+    try {
+      return await handle.result() as T;
+    } catch (error) {
+      handle = await client.workflow.start({
+        ...options,
+        workflowId: childJobId,
+        workflowTrace,
+        workflowSpan,
+      });
+      const result = await handle.result();
+      return result as T;
+    }
   }
 
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
@@ -172,7 +185,7 @@ export class WorkflowService {
       const trc = store.get('workflowTrace');
       const spn = store.get('workflowSpan');
       const activityTopic = `${workflowTopic}-activity`;
-      const activityJobId = `${workflowId}-${activityName}-${execIndex}`;
+      const activityJobId = `${workflowId}-$${activityName}-${execIndex}`;
 
       let activityState: JobOutput
       try {

package/services/store/index.ts

@@ -452,6 +452,9 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
   async getStatus(jobId: string, appId: string): Promise<number> {
     const jobKey = this.mintKey(KeyType.JOB_STATE, { appId, jobId });
     const status = await this.redisClient[this.commands.hget](jobKey, ':');
+    if (status === null) {
+      throw new Error(`Job ${jobId} not found`);
+    }
     return Number(status);
   }