@hotmeshio/hotmesh 0.0.7 → 0.0.9

package/LICENSE

@@ -178,13 +178,10 @@ Terms and Conditions for Use, Reproduction, and Distribution
       product that includes the Work or any part of it, as a commercial
       service to third parties, or in any other commercial context where
       you derive direct or indirect financial benefit from the use of the
-      Work. This includes, but is not limited to, providing 
-      routing-as-a-service, bpm-as-a-service, workflow-as-a-service,
-      integration-as-a-service, operational-data-as-a-service
-      or any other similar service that would compete with 
-      HotMesh's commercial offering of workflow and routing services.
-      Any such use requires explicit written permission from the
-      Licensor.
+      Work in a manner that would compete with the Licensor's commercial 
+      service-mesh-as-a-service, bpm-as-a-service, workflow-as-a-service,
+      integration-as-a-service or similar orchestration-type service.
+      Any such use requires explicit written permission from the Licensor.
 
    END OF TERMS AND CONDITIONS
 

package/README.md

@@ -1,7 +1,7 @@
 # HotMesh
 ![alpha release](https://img.shields.io/badge/release-alpha-yellow)
 
-Build sophisticated, durable workflows without the overhead of a dedicated server cluster. With HotMesh, your code remains front and center using [infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already own.
+Elevate Redis from an in-memory data store to a game-changing **service mesh**, delivering *durable* workflows without the overhead of a dedicated control plane. With HotMesh, you can keep your code at the forefront, utilizing [Redis infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already trust and own.
 
 ## Install
 [![npm version](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh.svg)](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh)
@@ -11,7 +11,9 @@ npm install @hotmeshio/hotmesh
 ```
 
 ## Design
-HotMesh's TypeScript SDK is modeled after [Temporal IO's](https://github.com/temporalio) developer-friendly approach. Design and deploy durable workflows using familiar paradigms that keep your code delightful to maintain. Deploying Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond using the HotMesh SDK and saving to Redis.
+HotMesh's TypeScript SDK is modeled after Temporal IO's developer-friendly approach. Design and deploy durable workflows using your preferred coding style. Write your functions as you normally would, then use the HotMesh to make them durable. Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond importing the HotMesh SDK.
+
+>Start by defining activities. These are the functions that will be invoked by your workflow. They 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.
 
 **./activities.ts**
 ```javascript
@@ -20,85 +22,74 @@ export async function greet(name: string): Promise<string> {
 }
 ```
 
+>Next, define your workflow. Include conditional logic, loops, etc. It's vanilla code written in your own coding style--just make sure to call `proxyActivities` to run your activities durably.
+
 **./workflows.ts**
 ```javascript
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+import * as activities from './activities';
 
-const { greet } = Durable.workflow.proxyActivities<typeof activities>();
+const { greet } = Durable.workflow
+  .proxyActivities<typeof activities>({
+    activities
+  });
 
 export async function example(name: string): Promise<string> {
   return await greet(name);
 }
 ```
 
-**./worker.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-import * as activities from './activities';
-
-async function run() {
-  const connection = await Durable.NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Durable.Worker.create({
-    connection,
-    namespace: 'default',
-    taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-```
+>Finally, create a worker and client. The *client* triggers workflows, while the *worker* runs them, retrying as necessary until the workflow succeeds--all without the need for complicated retry logic.
 
 **./client.ts**
 ```javascript
 import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
+import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
   const connection = await Durable.Connection.connect({
     class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
+    options: { host: 'localhost', port: 6379 }
   });
 
   const client = new Durable.Client({
-    connection,
+    connection
   });
 
   const handle = await client.workflow.start({
     args: ['HotMesh'],
     taskQueue: 'hello-world',
     workflowName: 'example',
-    workflowId: 'workflow-' + uuidv4(),
+    workflowId: 'workflow-' + uuidv4()
   });
 
-  console.log(`Started workflow ${handle.workflowId}`);
   console.log(await handle.result());
 }
+```
 
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+**./worker.ts**
+```javascript
+import { Durable } from '@hotmeshio/hotmesh';
+import Redis from 'ioredis';
+import * as workflows from './workflows';
+
+async function run() {
+  const connection = await Durable.NativeConnection.connect({
+    class: Redis,
+    options: { host: 'localhost', port: 6379 },
+  });
+  const worker = await Durable.Worker.create({
+    connection,
+    namespace: 'default',
+    taskQueue: 'hello-world',
+    workflow: workflows.example,
+  });
+  await worker.run();
+}
 ```
 
->HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design consumes leftover CPU on your microservices to execute workflows without the cost and complexity of a central server/control plane.
+>HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design delivers durable workflows without the cost and complexity of a centralized service mesh/control plane. Refer to the [hotmeshio/samples-typescript](https://github.com/hotmeshio/samples-typescript) Git Repo for a range of examples, including nested workflows.
 
 ## Advanced Design
 HotMesh's TypeScript SDK is the easiest way to make your functions durable. But if you need full control over your function lifecycles (including high-volume, high-speed use cases), you can use HotMesh's underlying YAML models to optimize your durable workflows. The following model depicts a sequence of activities orchestrated by HotMesh. Any function you associate with a `topic` in your YAML definition is guaranteed to be durable.

package/build/{esm/package.json → package.json}

@@ -1,14 +1,9 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.7",
+    "version": "0.0.9",
     "description": "Durable Workflows",
-    "main": "build/cjs/index.js",
-    "module": "build/esm/index.js",
-    "types": "build/cjs/index.d.ts",
-    "exports": {
-        "import": "./build/esm/index.js",
-        "require": "./build/cjs/index.js"
-    },
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
     },
     "scripts": {
         "clean": "rimraf ./build",
-        "build:cjs": "tsc --build tsconfig.cjs.json",
-        "build:esm": "tsc --build tsconfig.esm.json",
-        "build": "npm run build:cjs && npm run build:esm",
+        "build": "tsc --build tsconfig.json",
         "clean-build": "npm run clean && npm run build",
         "lint": "eslint . --ext .ts",
         "lint:fix": "eslint . --fix --ext .ts",
@@ -29,6 +22,7 @@
         "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
         "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
         "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
@@ -48,6 +42,7 @@
         "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
     },

package/build/{cjs/services → services}/activities/activity.d.ts

@@ -1,6 +1,7 @@
 import { EngineService } from '../engine';
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
+import { TelemetryService } from '../telemetry';
 import { ActivityData, ActivityLeg, ActivityMetadata, ActivityType } from '../../types/activity';
 import { JobState, JobStatus } from '../../types/job';
 import { MultiResponseFlags, RedisClient, RedisMulti } from '../../types/redis';
@@ -31,6 +32,11 @@ declare class Activity {
     processWebHookEvent(): Promise<JobStatus | void>;
     processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
     processHookEvent(jobId: string): Promise<JobStatus | void>;
+    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
+    processPending(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    processSuccess(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    processError(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;
     mapInputData(): void;

package/build/{cjs/services → services}/activities/activity.js

@@ -87,7 +87,7 @@ class Activity {
     setLeg(leg) {
         this.leg = leg;
     }
-    //********  SIGNALER RE-ENTRY POINT (B)  ********//
+    //********  SIGNAL RE-ENTRY POINT  ********//
     doesHook() {
         return !!(this.config.hook?.topic || this.config.sleep);
     }
@@ -125,11 +125,6 @@ class Activity {
         });
         return await this.processHookEvent(jobId);
     }
-    //todo: hooks are currently singletons. but they can support
-    //      dimensional threads like `await` and `worker` do.
-    //      Copy code from those activities to support cyclical
-    //      timehook and eventhook inputs by adding a 'pending'
-    //      flag to hooks that allows for repeated signals
     async processHookEvent(jobId) {
         this.logger.debug('activity-process-hook-event', { jobId });
         let telemetry;
@@ -159,7 +154,6 @@ class Activity {
             return jobStatus;
         }
         catch (error) {
-            console.error('this error?', error);
             this.logger.error('engine-process-hook-event-error', error);
             telemetry.setActivityError(error.message);
             throw error;
@@ -168,6 +162,88 @@ class Activity {
             telemetry.endActivitySpan();
         }
     }
+    //********  DUPLEX RE-ENTRY POINT  ********//
+    async processEvent(status = stream_1.StreamStatus.SUCCESS, code = 200) {
+        this.setLeg(2);
+        const jid = this.context.metadata.jid;
+        const aid = this.metadata.aid;
+        this.status = status;
+        this.code = code;
+        this.logger.debug('activity-process-event', { topic: this.config.subtype, jid, aid, status, code });
+        let telemetry;
+        try {
+            await this.getState();
+            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);
+            let isComplete = collator_1.CollatorService.isActivityComplete(this.context.metadata.js);
+            if (isComplete) {
+                this.logger.warn('activity-process-event-duplicate', { jid, aid });
+                this.logger.debug('activity-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
+                return;
+            }
+            telemetry.startActivitySpan(this.leg);
+            let multiResponse;
+            if (status === stream_1.StreamStatus.PENDING) {
+                multiResponse = await this.processPending(telemetry);
+            }
+            else if (status === stream_1.StreamStatus.SUCCESS) {
+                multiResponse = await this.processSuccess(telemetry);
+            }
+            else {
+                multiResponse = await this.processError(telemetry);
+            }
+            this.transitionAdjacent(multiResponse, telemetry);
+        }
+        catch (error) {
+            this.logger.error('activity-process-event-error', error);
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('activity-process-event-end', { jid, aid });
+        }
+    }
+    async processPending(telemetry) {
+        this.bindActivityData('output');
+        this.adjacencyList = await this.filterAdjacent();
+        this.mapJobData();
+        const multi = this.store.getMulti();
+        await this.setState(multi);
+        await collator_1.CollatorService.notarizeContinuation(this, multi);
+        await this.setStatus(this.adjacencyList.length, multi);
+        return await multi.exec();
+    }
+    async processSuccess(telemetry) {
+        this.bindActivityData('output');
+        this.adjacencyList = await this.filterAdjacent();
+        this.mapJobData();
+        const multi = this.store.getMulti();
+        await this.setState(multi);
+        await collator_1.CollatorService.notarizeCompletion(this, multi);
+        await this.setStatus(this.adjacencyList.length - 1, multi);
+        return await multi.exec();
+    }
+    async processError(telemetry) {
+        this.bindActivityError(this.data);
+        this.adjacencyList = await this.filterAdjacent();
+        const multi = this.store.getMulti();
+        await this.setState(multi);
+        await collator_1.CollatorService.notarizeCompletion(this, multi);
+        await this.setStatus(this.adjacencyList.length - 1, multi);
+        return await multi.exec();
+    }
+    async transitionAdjacent(multiResponse, telemetry) {
+        telemetry.mapActivityAttributes();
+        const jobStatus = this.resolveStatus(multiResponse);
+        const attrs = { 'app.job.jss': jobStatus };
+        const messageIds = await this.transition(this.adjacencyList, jobStatus);
+        if (messageIds.length) {
+            attrs['app.activity.mids'] = messageIds.join(',');
+        }
+        telemetry.setActivityAttributes(attrs);
+    }
     resolveStatus(multiResponse) {
         const activityStatus = multiResponse[multiResponse.length - 1];
         if (Array.isArray(activityStatus)) {

package/build/{cjs/services → services}/activities/await.d.ts

@@ -10,7 +10,7 @@ declare class Await extends Activity {
     process(): Promise<string>;
     execActivity(): Promise<string>;
     processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processSuccess(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
-    processError(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    processSuccessResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    processErrorResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
 }
 export { Await };

package/build/{cjs/services → services}/activities/await.js

@@ -22,7 +22,7 @@ class Await extends activity_1.Activity {
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
             const multi = this.store.getMulti();
-            //await this.registerTimeout();
+            //todo: await this.registerTimeout();
             await collator_1.CollatorService.authorizeReentry(this, multi);
             await this.setState(multi);
             await this.setStatus(0, multi);
@@ -95,12 +95,12 @@ class Await extends activity_1.Activity {
             if (status === stream_1.StreamStatus.SUCCESS) {
                 this.bindActivityData('output');
                 this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processSuccess(this.adjacencyList);
+                multiResponse = await this.processSuccessResponse(this.adjacencyList);
             }
             else {
                 this.bindActivityError(this.data);
                 this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processError(this.adjacencyList);
+                multiResponse = await this.processErrorResponse(this.adjacencyList);
             }
             telemetry.mapActivityAttributes();
             const jobStatus = this.resolveStatus(multiResponse);
@@ -121,7 +121,7 @@ class Await extends activity_1.Activity {
             this.logger.debug('await-resolve-await-end', { jid, aid, status, code });
         }
     }
-    async processSuccess(adjacencyList) {
+    async processSuccessResponse(adjacencyList) {
         this.mapJobData();
         const multi = this.store.getMulti();
         await this.setState(multi);
@@ -129,7 +129,7 @@ class Await extends activity_1.Activity {
         await this.setStatus(adjacencyList.length - 1, multi);
         return await multi.exec();
     }
-    async processError(adjacencyList) {
+    async processErrorResponse(adjacencyList) {
         //todo: if adjacencyList.length == 0, then map to the job output
         //      this method would be added to Base activity class 
         //this.mapJobData();

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

@@ -0,0 +1,19 @@
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import { ActivityData, ActivityMetadata, CycleActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
+declare class Cycle extends Activity {
+    config: CycleActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    /**
+     * Trigger the target ancestor to execute in a cycle,
+     * without violating the constraints of the DAG. Immutable
+     * `individual activity state` will execute in a new dimensional
+     * thread while `shared job state` can change. This
+     * pattern allows for retries without violating the DAG.
+     */
+    cycleAncestorActivity(multi: RedisMulti): Promise<string>;
+}
+export { Cycle };

package/build/services/activities/cycle.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cycle = void 0;
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../collator");
+const activity_1 = require("./activity");
+const telemetry_1 = require("../telemetry");
+class Cycle extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  LEG 1 ENTRY  ********//
+    async process() {
+        this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            //verify entry is allowed
+            this.setLeg(1);
+            await collator_1.CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            this.mapInputData();
+            //set state/status
+            let multi = this.store.getMulti();
+            await this.setState(multi);
+            await this.setStatus(0, multi); //leg 1 never changes job status
+            const multiResponse = await multi.exec();
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            //cycle the target ancestor
+            multi = this.store.getMulti();
+            const messageId = await this.cycleAncestorActivity(multi);
+            telemetry.setActivityAttributes({
+                'app.activity.mid': messageId,
+                'app.job.jss': jobStatus
+            });
+            //exit early (`Cycle` activities only execute Leg 1)
+            await collator_1.CollatorService.notarizeEarlyExit(this, multi);
+            await multi.exec();
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.GetStateError) {
+                this.logger.error('cycle-get-state-error', error);
+            }
+            else {
+                this.logger.error('cycle-process-error', error);
+            }
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    /**
+     * Trigger the target ancestor to execute in a cycle,
+     * without violating the constraints of the DAG. Immutable
+     * `individual activity state` will execute in a new dimensional
+     * thread while `shared job state` can change. This
+     * pattern allows for retries without violating the DAG.
+     */
+    async cycleAncestorActivity(multi) {
+        const streamData = {
+            metadata: {
+                dad: collator_1.CollatorService.resolveReentryDimension(this),
+                jid: this.context.metadata.jid,
+                aid: this.config.ancestor,
+            },
+            data: {} //todo: verify immutability, before enabling: `this.context.data`
+        };
+        return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi));
+    }
+}
+exports.Cycle = Cycle;

package/build/{esm/services → services}/activities/index.d.ts

@@ -1,12 +1,14 @@
 import { Activity } from './activity';
 import { Await } from './await';
-import { Worker } from './worker';
-import { Iterate } from './iterate';
+import { Cycle } from './cycle';
 import { Emit } from './emit';
+import { Iterate } from './iterate';
 import { Trigger } from './trigger';
+import { Worker } from './worker';
 declare const _default: {
     activity: typeof Activity;
     await: typeof Await;
+    cycle: typeof Cycle;
     iterate: typeof Iterate;
     emit: typeof Emit;
     trigger: typeof Trigger;

package/build/{cjs/services → services}/activities/index.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const activity_1 = require("./activity");
 const await_1 = require("./await");
-const worker_1 = require("./worker");
-const iterate_1 = require("./iterate");
+const cycle_1 = require("./cycle");
 const emit_1 = require("./emit");
+const iterate_1 = require("./iterate");
 const trigger_1 = require("./trigger");
+const worker_1 = require("./worker");
 exports.default = {
     activity: activity_1.Activity,
     await: await_1.Await,
+    cycle: cycle_1.Cycle,
     iterate: iterate_1.Iterate,
     emit: emit_1.Emit,
     trigger: trigger_1.Trigger,

package/build/{cjs/services → services}/activities/worker.d.ts

@@ -2,18 +2,10 @@ import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, ActivityType, WorkerActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
-import { MultiResponseFlags } from '../../types/redis';
-import { StreamCode, StreamStatus } from '../../types/stream';
-import { TelemetryService } from '../telemetry';
 declare class Worker extends Activity {
     config: WorkerActivity;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
     execActivity(): Promise<string>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processPending(telemetry: TelemetryService): Promise<void>;
-    processSuccess(telemetry: TelemetryService): Promise<void>;
-    processError(telemetry: TelemetryService): Promise<void>;
-    transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
 }
 export { Worker };

package/build/services/activities/worker.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const errors_1 = require("../../modules/errors");
+const activity_1 = require("./activity");
+const collator_1 = require("../collator");
+const telemetry_1 = require("../telemetry");
+class Worker extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            this.setLeg(1);
+            await collator_1.CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            this.mapInputData();
+            const multi = this.store.getMulti();
+            //todo: await this.registerTimeout();
+            await collator_1.CollatorService.authorizeReentry(this, multi);
+            await this.setState(multi);
+            await this.setStatus(0, multi);
+            const multiResponse = await multi.exec();
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            const messageId = await this.execActivity();
+            telemetry.setActivityAttributes({
+                'app.activity.mid': messageId,
+                'app.job.jss': jobStatus
+            });
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.GetStateError) {
+                this.logger.error('worker-get-state-error', error);
+            }
+            else {
+                this.logger.error('worker-process-error', error);
+            }
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    async execActivity() {
+        const streamData = {
+            metadata: {
+                jid: this.context.metadata.jid,
+                dad: this.metadata.dad,
+                aid: this.metadata.aid,
+                topic: this.config.subtype,
+                spn: this.context['$self'].output.metadata.l1s,
+                trc: this.context.metadata.trc,
+            },
+            data: this.context.data
+        };
+        if (this.config.retry) {
+            streamData.policies = {
+                retry: this.config.retry
+            };
+        }
+        return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData));
+    }
+}
+exports.Worker = Worker;

package/build/{esm/services → services}/collator/index.d.ts

@@ -3,11 +3,28 @@ import { CollationStage } from '../../types/collator';
 import { ActivityDuplex } from '../../types/activity';
 import { HotMeshGraph } from '../../types/hotmesh';
 import { Activity } from '../activities/activity';
+import { Cycle } from '../activities/cycle';
 declare class CollatorService {
     static targetLength: number;
-    static getDimensionalAddress(activity: Activity): Record<string, string>;
+    /**
+     * returns the dimensional address (dad) for the target; due
+     * to the nature of the notary system, the dad for leg 2 entry
+     * must target the `0` index while leg 2 exit must target the
+     * current index (0)
+     */
+    static getDimensionalAddress(activity: Activity, isEntry?: boolean): Record<string, string>;
+    /**
+     * resolves the dimensional address for the
+     * ancestor in the graph to go back to. this address
+     * is determined by trimming the last digits from
+     * the `dad` (including the target).
+     * the target activity index is then set to `0`, so that
+     * the origin node can be queried for approval/entry.
+     */
+    static resolveReentryDimension(activity: Cycle): string;
     static notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number>;
     static authorizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
+    static notarizeEarlyExit(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeContinuation(activity: Activity, multi?: RedisMulti): Promise<number>;