@hotmeshio/hotmesh 0.0.59 → 0.1.0

package/build/services/telemetry/index.js

@@ -60,7 +60,8 @@ class TelemetryService {
         else if (role === stream_1.StreamRole.WORKER) {
             type = 'EXECUTE';
         }
-        else if (data.type === stream_1.StreamDataType.RESULT || data.type === stream_1.StreamDataType.RESPONSE) {
+        else if (data.type === stream_1.StreamDataType.RESULT ||
+            data.type === stream_1.StreamDataType.RESPONSE) {
             type = 'FANIN';
         }
         else {
@@ -77,7 +78,7 @@ class TelemetryService {
         this.traceId = traceId;
         this.spanId = spanId;
         const tracer = telemetry_1.trace.getTracer(package_json_1.default.name, package_json_1.default.version);
-        let parentContext = this.getParentSpanContext();
+        const parentContext = this.getParentSpanContext();
         const span = tracer.startSpan(spanName, { kind: telemetry_1.SpanKind.CLIENT, attributes, root: !parentContext }, parentContext);
         return span;
     }
@@ -91,7 +92,7 @@ class TelemetryService {
                         result[`app.activity.data.${key}`] = telemetryAtts[key];
                     }
                     return result;
-                }, {})
+                }, {}),
             };
             this.span?.setAttributes(namespacedAtts);
         }
@@ -144,7 +145,6 @@ class TelemetryService {
             'app.activity.leg': leg,
         };
     }
-    ;
     getStreamSpanAttrs(input) {
         return {
             ...Object.keys(input.metadata).reduce((result, key) => {
@@ -152,10 +152,9 @@ class TelemetryService {
                     result[`app.stream.${key}`] = input.metadata[key];
                 }
                 return result;
-            }, {})
+            }, {}),
         };
     }
-    ;
     setTelemetryContext(span, leg) {
         if (!this.context.metadata.trc) {
             this.context.metadata.trc = span.spanContext().traceId;
@@ -208,22 +207,30 @@ class TelemetryService {
     static bindActivityTelemetryToState(state, config, metadata, context, leg) {
         if (config.type === 'trigger') {
             //trigger activities run non-duplexed and only have a single leg (2)
-            state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
-            state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l2s;
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l2s;
         }
-        else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' && leg === 1) {
+        else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' &&
+            leg === 1) {
             //hook activities run non-duplexed and only have a single leg (1)
-            state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
-            state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l1s;
         }
         else if (config.type === 'signal' && leg === 1) {
             //signal activities run non-duplexed and only have a single leg (1)
-            state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
-            state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l1s;
         }
         else {
             const target = `l${leg}s`;
-            state[`${metadata.aid}/output/metadata/${target}`] = context['$self'].output.metadata[target];
+            state[`${metadata.aid}/output/metadata/${target}`] =
+                context['$self'].output.metadata[target];
         }
     }
 }

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

@@ -1,13 +1,13 @@
 /// <reference types="node" />
-import { ILogger } from "../logger";
-import { Router } from "../router";
+import { ILogger } from '../logger';
+import { Router } from '../router';
 import { StoreService } from '../store';
 import { StreamService } from '../stream';
 import { SubService } from '../sub';
-import { HotMeshConfig, HotMeshWorker } from "../../types/hotmesh";
-import { RollCallMessage, SubscriptionCallback } from "../../types/quorum";
-import { RedisClient, RedisMulti } from "../../types/redis";
-import { StreamData, StreamDataResponse } from "../../types/stream";
+import { HotMeshConfig, HotMeshWorker } from '../../types/hotmesh';
+import { RollCallMessage, SubscriptionCallback } from '../../types/quorum';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { StreamData, StreamDataResponse } from '../../types/stream';
 declare class WorkerService {
     namespace: string;
     appId: string;

package/build/services/worker/index.js

@@ -38,7 +38,10 @@ class WorkerService {
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.guid);
                 await service.initStreamChannel(service, worker.stream);
                 service.router = service.initRouter(worker, logger);
-                const key = service.stream.mintKey(key_1.KeyType.STREAMS, { appId: service.appId, topic: worker.topic });
+                const key = service.stream.mintKey(key_1.KeyType.STREAMS, {
+                    appId: service.appId,
+                    topic: worker.topic,
+                });
                 await service.router.consumeMessages(key, 'WORKER', service.guid, worker.callback);
                 service.inited = (0, utils_1.formatISODate)(new Date());
                 services.push(service);
@@ -47,9 +50,9 @@ class WorkerService {
         return services;
     }
     verifyWorkerFields(worker) {
-        if ((!(0, utils_1.identifyRedisType)(worker.store) ||
+        if (!(0, utils_1.identifyRedisType)(worker.store) ||
             !(0, utils_1.identifyRedisType)(worker.stream) ||
-            !(0, utils_1.identifyRedisType)(worker.sub)) ||
+            !(0, utils_1.identifyRedisType)(worker.sub) ||
             !(worker.topic && worker.callback)) {
             throw new Error('worker must include `store`, `stream`, and `sub` fields along with a callback function and topic.');
         }
@@ -97,7 +100,8 @@ class WorkerService {
         return async (topic, message) => {
             self.logger.debug('worker-event-received', { topic, type: message.type });
             if (message.type === 'throttle') {
-                if (message.topic !== null) { //undefined allows passthrough
+                if (message.topic !== null) {
+                    //undefined allows passthrough
                     self.throttle(message.throttle);
                 }
             }
@@ -105,7 +109,8 @@ class WorkerService {
                 self.sayPong(self.appId, self.guid, message.originator, message.details);
             }
             else if (message.type === 'rollcall') {
-                if (message.topic !== null) { //undefined allows passthrough
+                if (message.topic !== null) {
+                    //undefined allows passthrough
                     self.doRollCall(message);
                 }
             }
@@ -117,10 +122,10 @@ class WorkerService {
      */
     async doRollCall(message) {
         let iteration = 0;
-        let max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
+        const max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
         if (this.rollCallInterval)
             clearTimeout(this.rollCallInterval);
-        const base = (message.interval / 2);
+        const base = message.interval / 2;
         const amount = base + Math.ceil(Math.random() * base);
         do {
             await (0, utils_1.sleepFor)(Math.ceil(Math.random() * 1000));

package/build/types/activity.d.ts

@@ -1,5 +1,5 @@
-import { MetricTypes } from "./stats";
-import { StreamRetryPolicy } from "./stream";
+import { MetricTypes } from './stats';
+import { StreamRetryPolicy } from './stream';
 type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'interrupt' | 'cycle' | 'signal' | 'hook';
 type Consumes = Record<string, string[]>;
 interface BaseActivity {
@@ -194,4 +194,4 @@ type ActivityDataType = {
     hook?: Record<string, unknown>;
 };
 type ActivityLeg = 1 | 2;
-export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, HookActivity, SignalActivity, BaseActivity, InterruptActivity, TriggerActivity, WorkerActivity };
+export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, HookActivity, SignalActivity, BaseActivity, InterruptActivity, TriggerActivity, WorkerActivity, };

package/build/types/exporter.d.ts

@@ -1,5 +1,5 @@
-import { StringAnyType } from "./serializer";
-export type ExportItem = [(string | null), string, any];
+import { StringAnyType } from './serializer';
+export type ExportItem = [string | null, string, any];
 /**
  * job export data can be large, particularly transitions the timeline
  */

package/build/types/exporter.js

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-;
-;
-;
-;
-;
-;

package/build/types/hook.d.ts

@@ -28,4 +28,4 @@ interface HookInterface {
         id: string;
     }): Promise<void>;
 }
-export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal };
+export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal, };

package/build/types/hotmesh.js

@@ -27,4 +27,3 @@ var KeyType;
     KeyType["WORK_ITEMS"] = "WORK_ITEMS";
 })(KeyType || (KeyType = {}));
 exports.KeyType = KeyType;
-;

package/build/types/index.d.ts

@@ -1,22 +1,22 @@
-export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, HookActivity, WorkerActivity, InterruptActivity, SignalActivity, TriggerActivity, TriggerActivityStats } from './activity';
+export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, HookActivity, WorkerActivity, InterruptActivity, SignalActivity, TriggerActivity, TriggerActivityStats, } from './activity';
 export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
 export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
-export { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType } from "./error";
-export { ActivityAction, DependencyExport, DurableJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline } from './exporter';
-export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
+export { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType, } from './error';
+export { ActivityAction, DependencyExport, DurableJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline, } from './exporter';
+export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal, } from './hook';
 export { ILogger } from './logger';
-export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState } from './job';
+export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, } from './job';
 export { MappingStatements } from './map';
-export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject } from './pipe';
-export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker, KeyStoreParams, KeyType } from './hotmesh';
-export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage } from './quorum';
+export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject, } from './pipe';
+export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker, KeyStoreParams, KeyType, } from './hotmesh';
+export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage, } from './quorum';
 export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, MultiResponseFlags, isRedisClient, isIORedisClient, } from './redis';
-export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets } from './serializer';
-export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment } from './stats';
-export { ReclaimedMessageType, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamRetryPolicy, StreamRole, StreamStatus } from './stream';
-export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType } from './telemetry';
+export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets, } from './serializer';
+export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment, } from './stats';
+export { ReclaimedMessageType, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamRetryPolicy, StreamRole, StreamStatus, } from './stream';
+export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType, } from './telemetry';
 export { WorkListTaskType } from './task';
 export { TransitionMatch, TransitionRule, Transitions } from './transition';

package/build/types/job.d.ts

@@ -1,4 +1,4 @@
-import { StringStringType } from "./serializer";
+import { StringStringType } from './serializer';
 type JobData = Record<string, unknown | Record<string, unknown>>;
 type JobsData = Record<string, unknown>;
 type ActivityData = {

package/build/types/logger.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-;

package/build/types/quorum.d.ts

@@ -1,4 +1,4 @@
-import { JobOutput } from "./job";
+import { JobOutput } from './job';
 interface CPULoad {
     [cpu: string]: string;
 }

package/build/types/stats.d.ts

@@ -81,4 +81,4 @@ interface IdsResponse {
     counts: CountByFacet[];
     segments: TimeSegment[];
 }
-export { StatsType, StatType, MetricTypes, JobStats, JobStatsRange, JobStatsInput, GetStatsOptions, StatsResponse, AggregatedData, Measure, Segment, IdsData, MeasureIds, TimeSegment, IdsResponse, CountByFacet };
+export { StatsType, StatType, MetricTypes, JobStats, JobStatsRange, JobStatsInput, GetStatsOptions, StatsResponse, AggregatedData, Measure, Segment, IdsData, MeasureIds, TimeSegment, IdsResponse, CountByFacet, };

package/build/types/stream.d.ts

@@ -91,8 +91,7 @@ export interface StreamData {
     stack?: string;
 }
 /** Extends StreamData for responses, allowing for inheritance of the base properties */
-export interface StreamDataResponse extends StreamData {
-}
+export type StreamDataResponse = StreamData;
 export declare enum StreamRole {
     WORKER = "worker",
     ENGINE = "engine",

package/build/types/telemetry.d.ts

@@ -1 +1 @@
-export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType } from '@opentelemetry/api';
+export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType, } from '@opentelemetry/api';

package/build/types/transition.d.ts

@@ -1,4 +1,4 @@
-import { Pipe } from "./pipe";
+import { Pipe } from './pipe';
 export type TransitionMatch = {
     expected: boolean | string | number | null;
     actual: boolean | string | number | null | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.59",
+  "version": "0.1.0",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -13,63 +13,63 @@
     "access": "public"
   },
   "scripts": {
-    "clean": "rimraf ./build",
     "build": "tsc --build tsconfig.json",
+    "clean": "rimraf ./build",
     "clean-build": "npm run clean && npm run build",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --fix --ext .ts",
     "start": "ts-node src/index.ts",
     "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
-    "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
-    "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:pipe": "NODE_ENV=test jest ./tests/unit/services/pipe/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/index.test.ts --detectOpenHandles --forceExit --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:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.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",
-    "test:functional": "NODE_ENV=test jest ./tests/functional/*/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:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:basic": "NODE_ENV=test jest ./tests/durable/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:collision": "NODE_ENV=test jest ./tests/durable/collision/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:interrupt": "NODE_ENV=test jest ./tests/durable/interrupt/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",
+    "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:reentrant": "NODE_ENV=test jest ./tests/functional/reentrant/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
     "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "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:pipe": "NODE_ENV=test jest ./tests/unit/services/pipe/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:reentrant": "NODE_ENV=test jest ./tests/functional/reentrant/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:retry": "NODE_ENV=test jest ./tests/functional/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:sequence": "NODE_ENV=test jest ./tests/functional/sequence/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:signal": "NODE_ENV=test jest ./tests/functional/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:basic": "NODE_ENV=test jest ./tests/durable/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:collision": "NODE_ENV=test jest ./tests/durable/collision/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",
-    "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/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"
+    "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose"
   },
   "keywords": [
+    "workflow",
     "durable workflow",
-    "HotMesh",
-    "service mesh",
-    "workflows",
     "operational data",
+    "service mesh",
+    "HotMesh",
     "Redis",
     "OLAP",
     "OLTP",
@@ -89,9 +89,12 @@
   "devDependencies": {
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
-    "@typescript-eslint/eslint-plugin": "^5.56.0",
-    "@typescript-eslint/parser": "^5.56.0",
-    "eslint": "^8.36.0",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
     "ioredis": "^5.3.2",
     "jest": "^29.5.0",
     "redis": "^4.6.13",
@@ -102,7 +105,7 @@
     "typescript": "^5.0.4"
   },
   "peerDependencies": {
-    "redis": "^4.0.0",
-    "ioredis": "^4.0.0 || ^5.0.0"
+    "ioredis": "^4.0.0 || ^5.0.0",
+    "redis": "^4.0.0"
   }
 }

package/types/activity.ts

@@ -1,7 +1,16 @@
-import { MetricTypes } from "./stats";
-import { StreamRetryPolicy } from "./stream";
-
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'interrupt' | 'cycle' | 'signal' | 'hook';
+import { MetricTypes } from './stats';
+import { StreamRetryPolicy } from './stream';
+
+type ActivityExecutionType =
+  | 'trigger'
+  | 'await'
+  | 'worker'
+  | 'activity'
+  | 'emit'
+  | 'interrupt'
+  | 'cycle'
+  | 'signal'
+  | 'hook';
 
 type Consumes = Record<string, string[]>;
 
@@ -15,20 +24,20 @@ interface BaseActivity {
   job?: Record<string, any>;
   hook?: Record<string, any>;
   telemetry?: Record<string, any>;
-  emit?: boolean;                      //if true, the activity will emit a message to the `publishes` topic immediately before transitioning to adjacent activities
-  sleep?: number;                      //@pipe /in seconds
-  expire?: number;                     //-1 forever; 0 persists the flow until the parent flow that expired it is dismissed; 15 seconds is the default
-  retry?: StreamRetryPolicy
-  cycle?: boolean;                     //if true, the `notary` will leave leg 2 open, so it can be re/cycled
-  collationInt?: number;               //compiler
-  consumes?: Consumes;                 //compiler
-  PRODUCES?: string[];                 //compiler
-  produces?: string[];                 //compiler
-  publishes?: string;                  //compiler 
-  subscribes?: string;                 //compiler
-  trigger?: string;                    //compiler
-  parent?: string;                     //compiler
-  ancestors?: string[];                //compiler
+  emit?: boolean; //if true, the activity will emit a message to the `publishes` topic immediately before transitioning to adjacent activities
+  sleep?: number; //@pipe /in seconds
+  expire?: number; //-1 forever; 0 persists the flow until the parent flow that expired it is dismissed; 15 seconds is the default
+  retry?: StreamRetryPolicy;
+  cycle?: boolean; //if true, the `notary` will leave leg 2 open, so it can be re/cycled
+  collationInt?: number; //compiler
+  consumes?: Consumes; //compiler
+  PRODUCES?: string[]; //compiler
+  produces?: string[]; //compiler
+  publishes?: string; //compiler
+  subscribes?: string; //compiler
+  trigger?: string; //compiler
+  parent?: string; //compiler
+  ancestors?: string[]; //compiler
 }
 
 interface Measure {
@@ -38,9 +47,9 @@ interface Measure {
 
 interface TriggerActivityStats {
   /**
-   * dependent parent job id; including this allows the parent's 
-   * expiration/interruption events to cascade; set 
-   * `expire` in the YAML for the dependent graph 
+   * dependent parent job id; including this allows the parent's
+   * expiration/interruption events to cascade; set
+   * `expire` in the YAML for the dependent graph
    * to 0 and provide the parent for dependent,
    * cascading interruption and cleanup
    */
@@ -96,50 +105,50 @@ interface HookActivity extends BaseActivity {
 }
 
 interface SignalActivity extends BaseActivity {
-  type: 'signal';                 //signal activities call hook/hookAll
-  subtype: 'one' | 'all';         //trigger: hook(One) or hookAll
-  topic: string;                  //e.g., 'hook.resume'
-  key_name?: string;              //e.g., 'parent_job_id'
-  key_value?: string;             //e.g., '1234567890'
-  scrub?: boolean;                //if true, the index will be deleted after use
-  signal?: Record<string, any>;   //used to define/map the signal input data (what to send/singnal into the job(s))
+  type: 'signal'; //signal activities call hook/hookAll
+  subtype: 'one' | 'all'; //trigger: hook(One) or hookAll
+  topic: string; //e.g., 'hook.resume'
+  key_name?: string; //e.g., 'parent_job_id'
+  key_value?: string; //e.g., '1234567890'
+  scrub?: boolean; //if true, the index will be deleted after use
+  signal?: Record<string, any>; //used to define/map the signal input data (what to send/singnal into the job(s))
   resolver?: Record<string, any>; //used to define/map the signal key resolver (the key used to lookup the job(s that are assigned to the key)
-  status?: string;                //pending, success (default), error
-  code?: number;                  //202, 200 (default)
+  status?: string; //pending, success (default), error
+  code?: number; //202, 200 (default)
 }
 
 interface InterruptActivity extends BaseActivity {
   type: 'interrupt';
 
-  /** 
+  /**
    * Optional Reason; will be used as the error `message` when thrown
    * @default 'Job Interrupted'
    */
   reason?: string;
 
-  /** 
+  /**
    * throw JobInterrupted error upon interrupting
    * @default true
    */
   throw?: boolean;
 
-  /** 
+  /**
    * Interrupt child/descendant jobs
    * @default false
    */
   descend?: boolean;
 
-  /** 
+  /**
    * Target job id (if not present the current job will be targeted)
    */
   target?: string;
 
-  /** 
+  /**
    * Optional topic to publish the interrupt message (if not present the current job topic will be used
    */
   topic?: string;
 
-  /** 
+  /**
    * Optional Error Code; will be used as the error `code` when thrown
    * @default 410
    */
@@ -151,7 +160,15 @@ interface InterruptActivity extends BaseActivity {
   stack?: string;
 }
 
-type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | InterruptActivity | HookActivity | SignalActivity | CycleActivity;
+type ActivityType =
+  | BaseActivity
+  | TriggerActivity
+  | AwaitActivity
+  | WorkerActivity
+  | InterruptActivity
+  | HookActivity
+  | SignalActivity
+  | CycleActivity;
 
 type ActivityData = Record<string, any>;
 
@@ -213,7 +230,7 @@ type ActivityMetadata = {
 type ActivityContext = {
   data?: ActivityData | null;
   metadata: ActivityMetadata;
-  hook?: ActivityData
+  hook?: ActivityData;
 };
 
 type ActivityDuplex = 1 | 2;
@@ -243,5 +260,5 @@ export {
   BaseActivity,
   InterruptActivity,
   TriggerActivity,
-  WorkerActivity
+  WorkerActivity,
 };

package/types/async.ts

@@ -1,7 +1,6 @@
-
 type AsyncSignal = {
-  topic: string,
-  jobId: string
+  topic: string;
+  jobId: string;
 };
 
 export { AsyncSignal };

package/types/collator.ts

@@ -1,9 +1,9 @@
 export type CollationStage = 'enter' | 'exit' | 'confirm';
 
 export enum CollationFaultType {
-  MISSING = 'missing',      //`as` uninitialized; leg1 entry not allowed
-  DUPLICATE = 'duplicate',  //1st digit < 8
-  INACTIVE = 'inactive',    //3rd digit is 8
-  INVALID = 'invalid',      //unknown value (corrupt for unknown reasons)
-  FORBIDDEN = 'forbidden',  //leg 1 not completed; reentry (leg 2) not allowed
+  MISSING = 'missing', //`as` uninitialized; leg1 entry not allowed
+  DUPLICATE = 'duplicate', //1st digit < 8
+  INACTIVE = 'inactive', //3rd digit is 8
+  INVALID = 'invalid', //unknown value (corrupt for unknown reasons)
+  FORBIDDEN = 'forbidden', //leg 1 not completed; reentry (leg 2) not allowed
 }