@hotmeshio/hotmesh 0.0.34 → 0.0.35

package/README.md

@@ -1,9 +1,9 @@
 # HotMesh
 ![alpha release](https://img.shields.io/badge/release-alpha-yellow)
 
-Elevate Redis from an in-memory data cache, and turn your unpredictable functions into unbreakable workflows. HotMesh is a distributed orchestration engine that governs the execution of your functions, ensuring they always complete successfully.
+HotMesh elevates Redis from an in-memory data cache to a distributed orchestration engine.
 
-*Write functions in your own preferred style, and let Redis govern their execution.*
+*Write functions in your own preferred style, and let Redis govern their execution, reliably and durably.*
 
 ## Install
 [![npm version](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh.svg)](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh)
@@ -11,7 +11,16 @@ Elevate Redis from an in-memory data cache, and turn your unpredictable function
 ```sh
 npm install @hotmeshio/hotmesh
 ```
+
+## Understanding HotMesh
+HotMesh inverts the relationship to Redis: those functions that once used Redis as a cache, are instead *cached and governed* by Redis. Consider the following. It's a typical microservices network, with a tangled mess of services and functions. There's important business logic in there (functions *A*, *B* and *C* are critical!), but they're hard to find and access.
+
+<img src="https://github.com/hotmeshio/sdk-typescript/blob/main/docs/img/operational_data_layer.png" alt="A Tangled Microservices Network with 3 functions buried within" style="max-width:100%;width:600px;">
+
+HotMesh creates an *ad hoc*, Redis-backed network of functions and organizes them into a unified service mesh. *Any service with access to Redis can join in the network, bypassing the legacy clutter.*
+
 ## Design
+The simplest way to get started is to use the `Durable` module. It's organized using principles similar to Temporal. If you're familiar with their SDK, the setup is similar.
 
 1. Start by defining **activities**. Activities can be written in any style, using any framework, and can even be legacy functions you've already written. The only requirement is that they return a Promise. *Note how the `saludar` example throws an error 50% of the time. It doesn't matter how unpredictable your functions are, HotMesh will retry as necessary until they succeed.*
     ```javascript
@@ -47,9 +56,8 @@ npm install @hotmeshio/hotmesh
 3. Instance a HotMesh **client** to invoke the workflow.
     ```javascript
     //client.ts
-    import { Durable } from '@hotmeshio/hotmesh';
+    import { Durable, HotMesh } from '@hotmeshio/hotmesh';
     import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-    import { nanoid } from 'nanoid';
 
     async function run(): Promise<string> {
       const client = new Durable.Client({
@@ -61,9 +69,9 @@ npm install @hotmeshio/hotmesh
 
       const handle = await client.workflow.start({
         args: ['HotMesh', 'es'],
-        taskQueue: 'hello-world',
+        taskQueue: 'default',
         workflowName: 'example',
-        workflowId: nanoid()
+        workflowId: HotMesh.guid()
       });
 
       return await handle.result();
@@ -83,7 +91,7 @@ npm install @hotmeshio/hotmesh
           class: Redis,
           options: { host: 'localhost', port: 6379 },
         },
-        taskQueue: 'hello-world',
+        taskQueue: 'default',
         workflow: workflows.example,
       });
 
@@ -92,7 +100,7 @@ npm install @hotmeshio/hotmesh
     ```
 
 ### Workflow Extensions
-Redis governance delivers more than just reliability. Externalizing state fundamentally changes the execution profile for your functions, allowing you to design long-running, durable workflows. The `Durable.workflow` base class (shown in the examples above) provides additional methods for solving the most common state management challenges.
+Redis governance delivers more than just reliability. Externalizing state fundamentally changes the execution profile for your functions, allowing you to design long-running, durable workflows. The `Durable` base class (shown in the examples above) provides additional methods for solving the most common state management challenges.
 
  - `waitForSignal` Pause your function and wait for external event(s) before continuing. The *waitForSignal* method will collate and cache the signals and only awaken your function once all signals have arrived.
    ```javascript
@@ -134,6 +142,10 @@ Redis governance delivers more than just reliability. Externalizing state fundam
       args: [{ id, user_id, etc }],
     });
     ```
+ - `getContext` Get the current workflow context (workflowId, etc).
+    ```javascript
+    const context = await Durable.workflow.getContext();
+    ```
  - `search` Instance a search session
     ```javascript
     const search = await Durable.workflow.search();
@@ -273,31 +285,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/tree/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/blob/main/docs/system_lifecycle.md#telemetry) telemetry insights into your legacy function executions.
 
 ## FAQ
-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.
+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.
 
 ## Quick Start
-Refer to the [Quick Start](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/quickstart.md) for sample flows you can easily copy, paste, and modify to get started.
+Refer to the [Quick Start](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/quickstart.md) for sample flows you can easily 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/tree/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/blob/main/docs/developer_guide.md).
 
 ## Model Driven Development
-[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.
+[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.
 
 ## 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/tree/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/blob/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/tree/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/blob/main/docs/composable_workflow.md).
 
 ## Distributed Orchestration
-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 detailed breakdown of the approach.
+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.
 
 ## System Lifecycle
-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).
+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).
 
 ## Alpha Release
-So what exacty is an [alpha release](https://github.com/hotmeshio/sdk-typescript/tree/main/docs/alpha.md)?
+So what exacty is an [alpha release](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/alpha.md)?

package/build/modules/enums.d.ts

@@ -0,0 +1,22 @@
+export declare const STATUS_CODE_SUCCESS = 200;
+export declare const STATUS_CODE_PENDING = 202;
+export declare const STATUS_CODE_TIMEOUT = 504;
+export declare const STATUS_CODE_INTERRUPT = 410;
+export declare const OTT_WAIT_TIME = 1000;
+export declare const MAX_RETRIES = 3;
+export declare const MAX_TIMEOUT_MS = 60000;
+export declare const GRADUATED_INTERVAL_MS = 5000;
+export declare const BLOCK_DURATION = 15000;
+export declare const TEST_BLOCK_DURATION = 1000;
+export declare const BLOCK_TIME_MS: number;
+export declare const XCLAIM_DELAY_MS: number;
+export declare const XCLAIM_COUNT = 3;
+export declare const XPENDING_COUNT = 10;
+export declare const STATUS_CODE_UNACKED = 999;
+export declare const STATUS_CODE_UNKNOWN = 500;
+export declare const STATUS_MESSAGE_UNKNOWN = "unknown";
+export declare const EXPIRE_DURATION = 15;
+export declare const BASE_FIDELITY_SECONDS = 15;
+export declare const TEST_FIDELITY_SECONDS = 5;
+export declare const FIDELITY_SECONDS: number;
+export declare const DURABLE_EXPIRE_SECONDS = 1;

package/build/modules/enums.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURABLE_EXPIRE_SECONDS = exports.FIDELITY_SECONDS = exports.TEST_FIDELITY_SECONDS = exports.BASE_FIDELITY_SECONDS = exports.EXPIRE_DURATION = exports.STATUS_MESSAGE_UNKNOWN = exports.STATUS_CODE_UNKNOWN = exports.STATUS_CODE_UNACKED = exports.XPENDING_COUNT = exports.XCLAIM_COUNT = exports.XCLAIM_DELAY_MS = exports.BLOCK_TIME_MS = exports.TEST_BLOCK_DURATION = exports.BLOCK_DURATION = exports.GRADUATED_INTERVAL_MS = exports.MAX_TIMEOUT_MS = exports.MAX_RETRIES = exports.OTT_WAIT_TIME = exports.STATUS_CODE_INTERRUPT = exports.STATUS_CODE_TIMEOUT = exports.STATUS_CODE_PENDING = exports.STATUS_CODE_SUCCESS = void 0;
+// Engine Constants
+exports.STATUS_CODE_SUCCESS = 200;
+exports.STATUS_CODE_PENDING = 202;
+exports.STATUS_CODE_TIMEOUT = 504;
+exports.STATUS_CODE_INTERRUPT = 410;
+exports.OTT_WAIT_TIME = 1000;
+// Stream Constants
+exports.MAX_RETRIES = 3; //local retry; 10, 100, 1000ms
+exports.MAX_TIMEOUT_MS = 60000;
+exports.GRADUATED_INTERVAL_MS = 5000;
+exports.BLOCK_DURATION = 15000; //Set to `15` so SIGINT/SIGTERM can interrupt; set to `0` to BLOCK indefinitely
+exports.TEST_BLOCK_DURATION = 1000; //Set to `1000` so tests can interrupt quickly
+exports.BLOCK_TIME_MS = process.env.NODE_ENV === 'test' ? exports.TEST_BLOCK_DURATION : exports.BLOCK_DURATION;
+exports.XCLAIM_DELAY_MS = 1000 * 60; //max time a message can be unacked before it is claimed by another
+exports.XCLAIM_COUNT = 3; //max number of times a message can be claimed by another before it is dead-lettered
+exports.XPENDING_COUNT = 10;
+exports.STATUS_CODE_UNACKED = 999;
+exports.STATUS_CODE_UNKNOWN = 500;
+exports.STATUS_MESSAGE_UNKNOWN = 'unknown';
+// HotMesh Constants
+exports.EXPIRE_DURATION = 15; // default expire in seconds; once job state semaphore reaches '0', this is applied to set Redis to expire the job HASH
+exports.BASE_FIDELITY_SECONDS = 15; // granularity resolution window size
+exports.TEST_FIDELITY_SECONDS = 5;
+exports.FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? exports.TEST_FIDELITY_SECONDS : exports.BASE_FIDELITY_SECONDS;
+// DURABLE CONSTANTS
+exports.DURABLE_EXPIRE_SECONDS = 1;

package/build/modules/errors.d.ts

@@ -1,7 +1,9 @@
 import { ActivityDuplex } from "../types/activity";
 import { CollationFaultType, CollationStage } from "../types/collator";
 declare class GetStateError extends Error {
-    constructor();
+    jobId: string;
+    code: 404;
+    constructor(jobId: string);
 }
 declare class SetStateError extends Error {
     constructor();
@@ -60,6 +62,12 @@ declare class RegisterTimeoutError extends Error {
 declare class DuplicateJobError extends Error {
     constructor(jobId: string);
 }
+declare class InactiveJobError extends Error {
+    jobId: string;
+    activityId: string;
+    status: number;
+    constructor(jobId: string, status: number, activityId: string);
+}
 declare class ExecActivityError extends Error {
     constructor();
 }
@@ -70,4 +78,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DurableTimeoutError, DurableMaxedError, DurableFatalError, DurableRetryError, DurableWaitForSignalError, DurableIncompleteSignalError, DurableSleepError, DurableSleepForError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };
+export { CollationError, DurableFatalError, DurableIncompleteSignalError, DurableMaxedError, DurableRetryError, DurableSleepError, DurableSleepForError, DurableTimeoutError, DurableWaitForSignalError, DuplicateJobError, ExecActivityError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };

package/build/modules/errors.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.DurableSleepForError = exports.DurableSleepError = exports.DurableIncompleteSignalError = exports.DurableWaitForSignalError = exports.DurableRetryError = exports.DurableFatalError = exports.DurableMaxedError = exports.DurableTimeoutError = exports.CollationError = void 0;
+exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.ExecActivityError = exports.DuplicateJobError = exports.DurableWaitForSignalError = exports.DurableTimeoutError = exports.DurableSleepForError = exports.DurableSleepError = exports.DurableRetryError = exports.DurableMaxedError = exports.DurableIncompleteSignalError = exports.DurableFatalError = exports.CollationError = void 0;
 class GetStateError extends Error {
-    constructor() {
-        super("Error occurred while getting job state");
+    constructor(jobId) {
+        super(`${jobId} Not Found`);
+        this.jobId = jobId;
     }
 }
 exports.GetStateError = GetStateError;
@@ -99,6 +100,16 @@ class DuplicateJobError extends Error {
     }
 }
 exports.DuplicateJobError = DuplicateJobError;
+class InactiveJobError extends Error {
+    constructor(jobId, status, activityId) {
+        super("Inactive job");
+        this.jobId = jobId;
+        this.activityId = activityId;
+        this.message = `Inactive job: ${jobId}`;
+        this.status = status;
+    }
+}
+exports.InactiveJobError = InactiveJobError;
 class ExecActivityError extends Error {
     constructor() {
         super("Error occurred while executing activity");

package/build/modules/key.d.ts

@@ -30,21 +30,22 @@ declare enum KeyType {
     APP = 0,
     ENGINE_ID = 1,
     HOOKS = 2,
-    JOB_STATE = 3,
-    JOB_STATS_GENERAL = 4,
-    JOB_STATS_MEDIAN = 5,
-    JOB_STATS_INDEX = 6,
-    HOTMESH = 7,
-    QUORUM = 8,
-    SCHEMAS = 9,
-    SIGNALS = 10,
-    STREAMS = 11,
-    SUBSCRIPTIONS = 12,
-    SUBSCRIPTION_PATTERNS = 13,
-    SYMKEYS = 14,
-    SYMVALS = 15,
-    TIME_RANGE = 16,
-    WORK_ITEMS = 17
+    JOB_DEPENDENTS = 3,
+    JOB_STATE = 4,
+    JOB_STATS_GENERAL = 5,
+    JOB_STATS_MEDIAN = 6,
+    JOB_STATS_INDEX = 7,
+    HOTMESH = 8,
+    QUORUM = 9,
+    SCHEMAS = 10,
+    SIGNALS = 11,
+    STREAMS = 12,
+    SUBSCRIPTIONS = 13,
+    SUBSCRIPTION_PATTERNS = 14,
+    SYMKEYS = 15,
+    SYMVALS = 16,
+    TIME_RANGE = 17,
+    WORK_ITEMS = 18
 }
 type KeyStoreParams = {
     appId?: string;

package/build/modules/key.js

@@ -37,21 +37,22 @@ var KeyType;
     KeyType[KeyType["APP"] = 0] = "APP";
     KeyType[KeyType["ENGINE_ID"] = 1] = "ENGINE_ID";
     KeyType[KeyType["HOOKS"] = 2] = "HOOKS";
-    KeyType[KeyType["JOB_STATE"] = 3] = "JOB_STATE";
-    KeyType[KeyType["JOB_STATS_GENERAL"] = 4] = "JOB_STATS_GENERAL";
-    KeyType[KeyType["JOB_STATS_MEDIAN"] = 5] = "JOB_STATS_MEDIAN";
-    KeyType[KeyType["JOB_STATS_INDEX"] = 6] = "JOB_STATS_INDEX";
-    KeyType[KeyType["HOTMESH"] = 7] = "HOTMESH";
-    KeyType[KeyType["QUORUM"] = 8] = "QUORUM";
-    KeyType[KeyType["SCHEMAS"] = 9] = "SCHEMAS";
-    KeyType[KeyType["SIGNALS"] = 10] = "SIGNALS";
-    KeyType[KeyType["STREAMS"] = 11] = "STREAMS";
-    KeyType[KeyType["SUBSCRIPTIONS"] = 12] = "SUBSCRIPTIONS";
-    KeyType[KeyType["SUBSCRIPTION_PATTERNS"] = 13] = "SUBSCRIPTION_PATTERNS";
-    KeyType[KeyType["SYMKEYS"] = 14] = "SYMKEYS";
-    KeyType[KeyType["SYMVALS"] = 15] = "SYMVALS";
-    KeyType[KeyType["TIME_RANGE"] = 16] = "TIME_RANGE";
-    KeyType[KeyType["WORK_ITEMS"] = 17] = "WORK_ITEMS";
+    KeyType[KeyType["JOB_DEPENDENTS"] = 3] = "JOB_DEPENDENTS";
+    KeyType[KeyType["JOB_STATE"] = 4] = "JOB_STATE";
+    KeyType[KeyType["JOB_STATS_GENERAL"] = 5] = "JOB_STATS_GENERAL";
+    KeyType[KeyType["JOB_STATS_MEDIAN"] = 6] = "JOB_STATS_MEDIAN";
+    KeyType[KeyType["JOB_STATS_INDEX"] = 7] = "JOB_STATS_INDEX";
+    KeyType[KeyType["HOTMESH"] = 8] = "HOTMESH";
+    KeyType[KeyType["QUORUM"] = 9] = "QUORUM";
+    KeyType[KeyType["SCHEMAS"] = 10] = "SCHEMAS";
+    KeyType[KeyType["SIGNALS"] = 11] = "SIGNALS";
+    KeyType[KeyType["STREAMS"] = 12] = "STREAMS";
+    KeyType[KeyType["SUBSCRIPTIONS"] = 13] = "SUBSCRIPTIONS";
+    KeyType[KeyType["SUBSCRIPTION_PATTERNS"] = 14] = "SUBSCRIPTION_PATTERNS";
+    KeyType[KeyType["SYMKEYS"] = 15] = "SYMKEYS";
+    KeyType[KeyType["SYMVALS"] = 16] = "SYMVALS";
+    KeyType[KeyType["TIME_RANGE"] = 17] = "TIME_RANGE";
+    KeyType[KeyType["WORK_ITEMS"] = 18] = "WORK_ITEMS";
 })(KeyType || (KeyType = {}));
 exports.KeyType = KeyType;
 class KeyService {
@@ -82,6 +83,8 @@ class KeyService {
                 return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
             case KeyType.JOB_STATE:
                 return `${namespace}:${params.appId}:j:${params.jobId}`;
+            case KeyType.JOB_DEPENDENTS:
+                return `${namespace}:${params.appId}:d:${params.jobId}`;
             case KeyType.JOB_STATS_GENERAL:
                 return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
             case KeyType.JOB_STATS_MEDIAN:

package/build/modules/utils.d.ts

@@ -5,6 +5,7 @@ import { RedisClient, RedisMulti } from "../types/redis";
 import { StringAnyType } from "../types/serializer";
 import { StreamCode, StreamStatus } from "../types/stream";
 export declare function sleepFor(ms: number): Promise<unknown>;
+export declare function guid(): string;
 export declare function deterministicRandom(seed: number): number;
 export declare function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null;
 export declare const polyfill: {

package/build/modules/utils.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.sleepFor = void 0;
+exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.guid = exports.sleepFor = void 0;
+const nanoid_1 = require("nanoid");
 async function sleepFor(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 exports.sleepFor = sleepFor;
+function guid() {
+    return (0, nanoid_1.nanoid)();
+}
+exports.guid = guid;
 function deterministicRandom(seed) {
     let x = Math.sin(seed) * 10000;
     return x - Math.floor(x);

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.34",
+    "version": "0.0.35",
     "description": "Unbreakable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -30,6 +30,7 @@
         "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:signal": "NODE_ENV=test jest ./tests/functional/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:interrupt": "NODE_ENV=test jest ./tests/functional/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:parallel": "NODE_ENV=test jest ./tests/functional/parallel/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sequence": "NODE_ENV=test jest ./tests/functional/sequence/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/index.test.ts --detectOpenHandles --forceExit --verbose",
@@ -46,6 +47,7 @@
         "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:meshos": "NODE_ENV=test jest ./tests/durable/meshos/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:interrupt": "NODE_ENV=test jest ./tests/durable/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",

package/build/services/activities/activity.d.ts

@@ -58,5 +58,10 @@ declare class Activity {
     resolveAdjacentDad(): string;
     filterAdjacent(): Promise<StreamData[]>;
     transition(adjacencyList: StreamData[], jobStatus: JobStatus): Promise<string[]>;
+    /**
+     * A job with a vale < -100_000_000 is considered interrupted,
+     * as the interruption event decrements the job status by 1billion.
+     */
+    jobWasInterrupted(jobStatus: JobStatus): boolean;
 }
 export { Activity, ActivityType };

package/build/services/activities/activity.js

@@ -9,6 +9,7 @@ const pipe_1 = require("../pipe");
 const serializer_1 = require("../serializer");
 const telemetry_1 = require("../telemetry");
 const stream_1 = require("../../types/stream");
+const enums_1 = require("../../modules/enums");
 /**
  * The base class for all activities
  */
@@ -44,6 +45,7 @@ class Activity {
         let telemetry;
         try {
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             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);
@@ -71,12 +73,20 @@ class Activity {
                 this.logger.info('process-event-inactive-error', { error });
                 return;
             }
+            else if (error instanceof errors_1.InactiveJobError) {
+                this.logger.info('process-event-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
+                this.logger.info('process-event-get-job-error', { error });
+                return;
+            }
             this.logger.error('activity-process-event-error', { error });
             telemetry && telemetry.setActivityError(error.message);
             throw error;
         }
         finally {
-            telemetry && telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('activity-process-event-end', { jid, aid });
         }
     }
@@ -113,6 +123,7 @@ class Activity {
         telemetry.mapActivityAttributes();
         const jobStatus = this.resolveStatus(multiResponse);
         const attrs = { 'app.job.jss': jobStatus };
+        //adjacencyList membership has already been set at this point (according to activity status)
         const messageIds = await this.transition(this.adjacencyList, jobStatus);
         if (messageIds.length) {
             attrs['app.activity.mids'] = messageIds.join(',');
@@ -307,11 +318,12 @@ class Activity {
             self.hook = {};
         }
         context['$self'] = self;
-        context['$job'] = context; //NEVER call STRINGIFY! (circular)
+        context['$job'] = context; //NEVER call STRINGIFY! (now circular)
         return context;
     }
     initPolicies(context) {
-        context.metadata.expire = this.config.expire;
+        const expire = pipe_1.Pipe.resolve(this.config.expire ?? enums_1.EXPIRE_DURATION, context);
+        context.metadata.expire = expire;
     }
     bindActivityData(type) {
         this.context[this.metadata.aid][type].data = this.data;
@@ -341,6 +353,7 @@ class Activity {
                 if (mapper_1.MapperService.evaluate(transitionRule, this.context, this.code)) {
                     adjacencyList.push({
                         metadata: {
+                            guid: (0, utils_1.guid)(),
                             jid: this.context.metadata.jid,
                             dad: adjacentDad,
                             aid: toActivityId,
@@ -356,15 +369,16 @@ class Activity {
         return adjacencyList;
     }
     async transition(adjacencyList, jobStatus) {
+        if (this.jobWasInterrupted(jobStatus)) {
+            return;
+        }
         let mIds = [];
         let emit = false;
         if (this.config.emit) {
             emit = pipe_1.Pipe.resolve(this.config.emit, this.context);
         }
         if (jobStatus <= 0 || emit) {
-            //activity should not send 'emit' if the job is truly over
-            const isTrueEmit = jobStatus > 0;
-            await this.engine.runJobCompletionTasks(this.context, isTrueEmit);
+            await this.engine.runJobCompletionTasks(this.context, { emit: jobStatus > 0 });
         }
         if (adjacencyList.length && jobStatus > 0) {
             const multi = this.store.getMulti();
@@ -375,5 +389,12 @@ class Activity {
         }
         return mIds;
     }
+    /**
+     * A job with a vale < -100_000_000 is considered interrupted,
+     * as the interruption event decrements the job status by 1billion.
+     */
+    jobWasInterrupted(jobStatus) {
+        return jobStatus < -100000000;
+    }
 }
 exports.Activity = Activity;

package/build/services/activities/await.js

@@ -7,6 +7,7 @@ const collator_1 = require("../collator");
 const stream_1 = require("../../types/stream");
 const telemetry_1 = require("../telemetry");
 const pipe_1 = require("../pipe");
+const utils_1 = require("../../modules/utils");
 class Await extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);
@@ -20,6 +21,7 @@ class Await extends activity_1.Activity {
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
@@ -41,17 +43,22 @@ class Await extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            telemetry.setActivityError(error.message);
-            if (error instanceof errors_1.GetStateError) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('await-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
                 this.logger.error('await-get-state-error', { error });
+                return;
             }
             else {
                 this.logger.error('await-process-error', { error });
             }
+            telemetry.setActivityError(error.message);
             throw error;
         }
         finally {
-            telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('await-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }
@@ -59,6 +66,7 @@ class Await extends activity_1.Activity {
         const topic = pipe_1.Pipe.resolve(this.config.subtype, this.context);
         const streamData = {
             metadata: {
+                guid: (0, utils_1.guid)(),
                 jid: this.context.metadata.jid,
                 dad: this.metadata.dad,
                 aid: this.metadata.aid,

package/build/services/activities/cycle.js

@@ -5,6 +5,7 @@ const errors_1 = require("../../modules/errors");
 const collator_1 = require("../collator");
 const activity_1 = require("./activity");
 const telemetry_1 = require("../telemetry");
+const utils_1 = require("../../modules/utils");
 class Cycle extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);
@@ -18,6 +19,7 @@ class Cycle extends activity_1.Activity {
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
@@ -41,8 +43,13 @@ class Cycle extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            if (error instanceof errors_1.GetStateError) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('cycle-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
                 this.logger.error('cycle-get-state-error', { error });
+                return;
             }
             else {
                 this.logger.error('cycle-process-error', { error });
@@ -51,7 +58,7 @@ class Cycle extends activity_1.Activity {
             throw error;
         }
         finally {
-            telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }
@@ -70,6 +77,7 @@ class Cycle extends activity_1.Activity {
         this.mapInputData();
         const streamData = {
             metadata: {
+                guid: (0, utils_1.guid)(),
                 dad: collator_1.CollatorService.resolveReentryDimension(this),
                 jid: this.context.metadata.jid,
                 aid: this.config.ancestor,

package/build/services/activities/hook.js

@@ -23,6 +23,7 @@ class Hook extends activity_1.Activity {
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             let multiResponse;
@@ -59,8 +60,13 @@ class Hook extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            if (error instanceof errors_1.GetStateError) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('hook-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
                 this.logger.error('hook-get-state-error', { error });
+                return;
             }
             else {
                 this.logger.error('hook-process-error', { error });
@@ -69,7 +75,7 @@ class Hook extends activity_1.Activity {
             throw error;
         }
         finally {
-            telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }

package/build/services/activities/index.d.ts

@@ -2,7 +2,7 @@ import { Activity } from './activity';
 import { Await } from './await';
 import { Cycle } from './cycle';
 import { Hook } from './hook';
-import { Iterate } from './iterate';
+import { Interrupt } from './interrupt';
 import { Signal } from './signal';
 import { Trigger } from './trigger';
 import { Worker } from './worker';
@@ -11,7 +11,7 @@ declare const _default: {
     await: typeof Await;
     cycle: typeof Cycle;
     hook: typeof Hook;
-    iterate: typeof Iterate;
+    interrupt: typeof Interrupt;
     signal: typeof Signal;
     trigger: typeof Trigger;
     worker: typeof Worker;