@hotmeshio/hotmesh 0.1.15 → 0.1.16

package/build/index.d.ts

@@ -1,5 +1,16 @@
-import { Durable } from './services/durable';
-import { HotMeshService as HotMesh } from './services/hotmesh';
+import { MeshCall } from './services/meshcall';
+import { MeshData } from './services/meshdata';
+import { HotMesh } from './services/hotmesh';
+import { ClientService } from './services/meshflow/client';
+import { WorkerService } from './services/meshflow/worker';
+import { WorkflowService } from './services/meshflow/workflow';
+import { ConnectionService } from './services/meshflow/connection';
 import { HotMeshConfig } from './types/hotmesh';
-export { Durable, HotMesh, HotMeshConfig };
+declare const MeshFlow: {
+    Client: typeof ClientService;
+    Worker: typeof WorkerService;
+    workflow: typeof WorkflowService;
+    Connection: typeof ConnectionService;
+};
+export { HotMesh, MeshCall, MeshData, MeshFlow, HotMeshConfig, };
 export * as Types from './types';

package/build/index.js

@@ -23,9 +23,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.HotMesh = exports.Durable = void 0;
-const durable_1 = require("./services/durable");
-Object.defineProperty(exports, "Durable", { enumerable: true, get: function () { return durable_1.Durable; } });
+exports.Types = exports.MeshFlow = exports.MeshData = exports.MeshCall = exports.HotMesh = void 0;
+const meshcall_1 = require("./services/meshcall");
+Object.defineProperty(exports, "MeshCall", { enumerable: true, get: function () { return meshcall_1.MeshCall; } });
+const meshdata_1 = require("./services/meshdata");
+Object.defineProperty(exports, "MeshData", { enumerable: true, get: function () { return meshdata_1.MeshData; } });
 const hotmesh_1 = require("./services/hotmesh");
-Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMeshService; } });
+Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
+const client_1 = require("./services/meshflow/client");
+const worker_1 = require("./services/meshflow/worker");
+const workflow_1 = require("./services/meshflow/workflow");
+const connection_1 = require("./services/meshflow/connection");
+const MeshFlow = {
+    Client: client_1.ClientService,
+    Worker: worker_1.WorkerService,
+    workflow: workflow_1.WorkflowService,
+    Connection: connection_1.ConnectionService,
+};
+exports.MeshFlow = MeshFlow;
 exports.Types = __importStar(require("./types"));

package/build/modules/enums.d.ts

@@ -8,15 +8,15 @@ export declare const HMSH_CODE_INTERRUPT = 410;
 export declare const HMSH_CODE_UNKNOWN = 500;
 export declare const HMSH_CODE_TIMEOUT = 504;
 export declare const HMSH_CODE_UNACKED = 999;
-export declare const HMSH_CODE_DURABLE_SLEEP = 588;
-export declare const HMSH_CODE_DURABLE_ALL = 589;
-export declare const HMSH_CODE_DURABLE_CHILD = 590;
-export declare const HMSH_CODE_DURABLE_PROXY = 591;
-export declare const HMSH_CODE_DURABLE_WAIT = 595;
-export declare const HMSH_CODE_DURABLE_TIMEOUT = 596;
-export declare const HMSH_CODE_DURABLE_MAXED = 597;
-export declare const HMSH_CODE_DURABLE_FATAL = 598;
-export declare const HMSH_CODE_DURABLE_RETRYABLE = 599;
+export declare const HMSH_CODE_MESHFLOW_SLEEP = 588;
+export declare const HMSH_CODE_MESHFLOW_ALL = 589;
+export declare const HMSH_CODE_MESHFLOW_CHILD = 590;
+export declare const HMSH_CODE_MESHFLOW_PROXY = 591;
+export declare const HMSH_CODE_MESHFLOW_WAIT = 595;
+export declare const HMSH_CODE_MESHFLOW_TIMEOUT = 596;
+export declare const HMSH_CODE_MESHFLOW_MAXED = 597;
+export declare const HMSH_CODE_MESHFLOW_FATAL = 598;
+export declare const HMSH_CODE_MESHFLOW_RETRYABLE = 599;
 export declare const HMSH_STATUS_UNKNOWN = "unknown";
 export declare const HMSH_QUORUM_ROLLCALL_CYCLES = 12;
 export declare const HMSH_QUORUM_DELAY_MS = 250;
@@ -27,9 +27,9 @@ export declare const MAX_DELAY = 2147483647;
 export declare const HMSH_MAX_RETRIES: number;
 export declare const HMSH_MAX_TIMEOUT_MS: number;
 export declare const HMSH_GRADUATED_INTERVAL_MS: number;
-export declare const HMSH_DURABLE_MAX_ATTEMPTS = 3;
-export declare const HMSH_DURABLE_MAX_INTERVAL = "120s";
-export declare const HMSH_DURABLE_EXP_BACKOFF = 10;
+export declare const HMSH_MESHFLOW_MAX_ATTEMPTS = 3;
+export declare const HMSH_MESHFLOW_MAX_INTERVAL = "120s";
+export declare const HMSH_MESHFLOW_EXP_BACKOFF = 10;
 export declare const HMSH_BLOCK_TIME_MS: number;
 export declare const HMSH_XCLAIM_DELAY_MS: number;
 export declare const HMSH_XCLAIM_COUNT: number;

package/build/modules/enums.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_DURABLE_EXP_BACKOFF = exports.HMSH_DURABLE_MAX_INTERVAL = exports.HMSH_DURABLE_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_DURABLE_RETRYABLE = exports.HMSH_CODE_DURABLE_FATAL = exports.HMSH_CODE_DURABLE_MAXED = exports.HMSH_CODE_DURABLE_TIMEOUT = exports.HMSH_CODE_DURABLE_WAIT = exports.HMSH_CODE_DURABLE_PROXY = exports.HMSH_CODE_DURABLE_CHILD = exports.HMSH_CODE_DURABLE_ALL = exports.HMSH_CODE_DURABLE_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_IS_CLUSTER = exports.HMSH_LOGLEVEL = void 0;
-// HOTMESH SYSTEM
+exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MESHFLOW_EXP_BACKOFF = exports.HMSH_MESHFLOW_MAX_INTERVAL = exports.HMSH_MESHFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MESHFLOW_RETRYABLE = exports.HMSH_CODE_MESHFLOW_FATAL = exports.HMSH_CODE_MESHFLOW_MAXED = exports.HMSH_CODE_MESHFLOW_TIMEOUT = exports.HMSH_CODE_MESHFLOW_WAIT = exports.HMSH_CODE_MESHFLOW_PROXY = exports.HMSH_CODE_MESHFLOW_CHILD = exports.HMSH_CODE_MESHFLOW_ALL = exports.HMSH_CODE_MESHFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_IS_CLUSTER = exports.HMSH_LOGLEVEL = void 0;
 exports.HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL || 'info';
 exports.HMSH_IS_CLUSTER = process.env.HMSH_IS_CLUSTER === 'true';
-// HOTMESH STATUS CODES
 exports.HMSH_CODE_SUCCESS = 200;
 exports.HMSH_CODE_PENDING = 202;
 exports.HMSH_CODE_NOTFOUND = 404;
@@ -12,34 +10,28 @@ exports.HMSH_CODE_INTERRUPT = 410;
 exports.HMSH_CODE_UNKNOWN = 500;
 exports.HMSH_CODE_TIMEOUT = 504;
 exports.HMSH_CODE_UNACKED = 999;
-// DURABLE STATUS CODES
-exports.HMSH_CODE_DURABLE_SLEEP = 588;
-exports.HMSH_CODE_DURABLE_ALL = 589;
-exports.HMSH_CODE_DURABLE_CHILD = 590;
-exports.HMSH_CODE_DURABLE_PROXY = 591;
-exports.HMSH_CODE_DURABLE_WAIT = 595;
-exports.HMSH_CODE_DURABLE_TIMEOUT = 596;
-exports.HMSH_CODE_DURABLE_MAXED = 597;
-exports.HMSH_CODE_DURABLE_FATAL = 598;
-exports.HMSH_CODE_DURABLE_RETRYABLE = 599;
-// HOTMESH MESSAGES
+exports.HMSH_CODE_MESHFLOW_SLEEP = 588;
+exports.HMSH_CODE_MESHFLOW_ALL = 589;
+exports.HMSH_CODE_MESHFLOW_CHILD = 590;
+exports.HMSH_CODE_MESHFLOW_PROXY = 591;
+exports.HMSH_CODE_MESHFLOW_WAIT = 595;
+exports.HMSH_CODE_MESHFLOW_TIMEOUT = 596;
+exports.HMSH_CODE_MESHFLOW_MAXED = 597;
+exports.HMSH_CODE_MESHFLOW_FATAL = 598;
+exports.HMSH_CODE_MESHFLOW_RETRYABLE = 599;
 exports.HMSH_STATUS_UNKNOWN = 'unknown';
-// QUORUM
-exports.HMSH_QUORUM_ROLLCALL_CYCLES = 12; //max iterations
+exports.HMSH_QUORUM_ROLLCALL_CYCLES = 12;
 exports.HMSH_QUORUM_DELAY_MS = 250;
 exports.HMSH_ACTIVATION_MAX_RETRY = 3;
-// ENGINE
 exports.HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
 exports.HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
-// STREAM ROUTER
-exports.MAX_DELAY = 2147483647; // Maximum allowed delay in milliseconds for setTimeout
+exports.MAX_DELAY = 2147483647;
 exports.HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
 exports.HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
 exports.HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
-// DURABLE
-exports.HMSH_DURABLE_MAX_ATTEMPTS = 3;
-exports.HMSH_DURABLE_MAX_INTERVAL = '120s';
-exports.HMSH_DURABLE_EXP_BACKOFF = 10;
+exports.HMSH_MESHFLOW_MAX_ATTEMPTS = 3;
+exports.HMSH_MESHFLOW_MAX_INTERVAL = '120s';
+exports.HMSH_MESHFLOW_EXP_BACKOFF = 10;
 const BASE_BLOCK_DURATION = 10000;
 const TEST_BLOCK_DURATION = 1000;
 exports.HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS
@@ -50,7 +42,6 @@ exports.HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS
 exports.HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
 exports.HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
 exports.HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
-// TASK WORKER
 exports.HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
 const BASE_FIDELITY_SECONDS = 5;
 const TEST_FIDELITY_SECONDS = 1;
@@ -60,5 +51,4 @@ exports.HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS
         ? TEST_FIDELITY_SECONDS
         : BASE_FIDELITY_SECONDS;
 exports.HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;
-// UTILS
 exports.HMSH_GUID_SIZE = Math.min(parseInt(process.env.HMSH_GUID_SIZE, 10) || 22, 32);

package/build/modules/errors.d.ts

@@ -1,6 +1,6 @@
 import { ActivityDuplex } from '../types/activity';
 import { CollationFaultType, CollationStage } from '../types/collator';
-import { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType } from '../types/error';
+import { MeshFlowChildErrorType, MeshFlowProxyErrorType, MeshFlowSleepErrorType, MeshFlowWaitForAllErrorType, MeshFlowWaitForErrorType } from '../types/error';
 declare class GetStateError extends Error {
     jobId: string;
     code: number;
@@ -9,15 +9,15 @@ declare class GetStateError extends Error {
 declare class SetStateError extends Error {
     constructor();
 }
-declare class DurableWaitForError extends Error {
+declare class MeshFlowWaitForError extends Error {
     code: number;
     signalId: string;
     workflowId: string;
     index: number;
     workflowDimension: string;
-    constructor(params: DurableWaitForErrorType);
+    constructor(params: MeshFlowWaitForErrorType);
 }
-declare class DurableProxyError extends Error {
+declare class MeshFlowProxyError extends Error {
     activityName: string;
     arguments: string[];
     backoffCoefficient: number;
@@ -31,9 +31,9 @@ declare class DurableProxyError extends Error {
     workflowDimension: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: DurableProxyErrorType);
+    constructor(params: MeshFlowProxyErrorType);
 }
-declare class DurableChildError extends Error {
+declare class MeshFlowChildError extends Error {
     await: boolean;
     arguments: string[];
     backoffCoefficient: number;
@@ -48,9 +48,9 @@ declare class DurableChildError extends Error {
     parentWorkflowId: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: DurableChildErrorType);
+    constructor(params: MeshFlowChildErrorType);
 }
-declare class DurableWaitForAllError extends Error {
+declare class MeshFlowWaitForAllError extends Error {
     items: any[];
     code: number;
     workflowDimension: string;
@@ -60,29 +60,29 @@ declare class DurableWaitForAllError extends Error {
     parentWorkflowId: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: DurableWaitForAllErrorType);
+    constructor(params: MeshFlowWaitForAllErrorType);
 }
-declare class DurableSleepError extends Error {
+declare class MeshFlowSleepError extends Error {
     workflowId: string;
     code: number;
     duration: number;
     index: number;
     workflowDimension: string;
-    constructor(params: DurableSleepErrorType);
+    constructor(params: MeshFlowSleepErrorType);
 }
-declare class DurableTimeoutError extends Error {
+declare class MeshFlowTimeoutError extends Error {
     code: number;
     constructor(message: string, stack?: string);
 }
-declare class DurableMaxedError extends Error {
+declare class MeshFlowMaxedError extends Error {
     code: number;
     constructor(message: string, stackTrace?: string);
 }
-declare class DurableFatalError extends Error {
+declare class MeshFlowFatalError extends Error {
     code: number;
     constructor(message: string, stackTrace?: string);
 }
-declare class DurableRetryError extends Error {
+declare class MeshFlowRetryError extends Error {
     code: number;
     constructor(message: string, stackTrace?: string);
 }
@@ -120,4 +120,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DurableChildError, DurableFatalError, DurableMaxedError, DurableProxyError, DurableRetryError, DurableSleepError, DurableTimeoutError, DurableWaitForAllError, DurableWaitForError, DuplicateJobError, ExecActivityError, GenerationalError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };
+export { CollationError, MeshFlowChildError, MeshFlowFatalError, MeshFlowMaxedError, MeshFlowProxyError, MeshFlowRetryError, MeshFlowSleepError, MeshFlowTimeoutError, MeshFlowWaitForAllError, MeshFlowWaitForError, DuplicateJobError, ExecActivityError, GenerationalError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };

package/build/modules/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.GenerationalError = exports.ExecActivityError = exports.DuplicateJobError = exports.DurableWaitForError = exports.DurableWaitForAllError = exports.DurableTimeoutError = exports.DurableSleepError = exports.DurableRetryError = exports.DurableProxyError = exports.DurableMaxedError = exports.DurableFatalError = exports.DurableChildError = exports.CollationError = void 0;
+exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.GenerationalError = exports.ExecActivityError = exports.DuplicateJobError = exports.MeshFlowWaitForError = exports.MeshFlowWaitForAllError = exports.MeshFlowTimeoutError = exports.MeshFlowSleepError = exports.MeshFlowRetryError = exports.MeshFlowProxyError = exports.MeshFlowMaxedError = exports.MeshFlowFatalError = exports.MeshFlowChildError = exports.CollationError = void 0;
 const enums_1 = require("./enums");
 class GetStateError extends Error {
     constructor(jobId) {
@@ -16,17 +16,17 @@ class SetStateError extends Error {
     }
 }
 exports.SetStateError = SetStateError;
-class DurableWaitForError extends Error {
+class MeshFlowWaitForError extends Error {
     constructor(params) {
         super(`WaitFor Interruption`);
         this.signalId = params.signalId;
         this.index = params.index;
         this.workflowDimension = params.workflowDimension;
-        this.code = enums_1.HMSH_CODE_DURABLE_WAIT;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_WAIT;
     }
 }
-exports.DurableWaitForError = DurableWaitForError;
-class DurableProxyError extends Error {
+exports.MeshFlowWaitForError = MeshFlowWaitForError;
+class MeshFlowProxyError extends Error {
     constructor(params) {
         super(`ProxyActivity Interruption`);
         this.arguments = params.arguments;
@@ -41,11 +41,11 @@ class DurableProxyError extends Error {
         this.backoffCoefficient = params.backoffCoefficient;
         this.maximumAttempts = params.maximumAttempts;
         this.maximumInterval = params.maximumInterval;
-        this.code = enums_1.HMSH_CODE_DURABLE_PROXY;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_PROXY;
     }
 }
-exports.DurableProxyError = DurableProxyError;
-class DurableChildError extends Error {
+exports.MeshFlowProxyError = MeshFlowProxyError;
+class MeshFlowChildError extends Error {
     constructor(params) {
         super(`ExecChild Interruption`);
         this.arguments = params.arguments;
@@ -57,15 +57,15 @@ class DurableChildError extends Error {
         this.originJobId = params.originJobId;
         this.index = params.index;
         this.workflowDimension = params.workflowDimension;
-        this.code = enums_1.HMSH_CODE_DURABLE_CHILD;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_CHILD;
         this.await = params.await;
         this.backoffCoefficient = params.backoffCoefficient;
         this.maximumAttempts = params.maximumAttempts;
         this.maximumInterval = params.maximumInterval;
     }
 }
-exports.DurableChildError = DurableChildError;
-class DurableWaitForAllError extends Error {
+exports.MeshFlowChildError = MeshFlowChildError;
+class MeshFlowWaitForAllError extends Error {
     constructor(params) {
         super(`Collation Interruption`);
         this.items = params.items;
@@ -76,61 +76,61 @@ class DurableWaitForAllError extends Error {
         this.originJobId = params.originJobId;
         this.index = params.index;
         this.workflowDimension = params.workflowDimension;
-        this.code = enums_1.HMSH_CODE_DURABLE_ALL;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_ALL;
     }
 }
-exports.DurableWaitForAllError = DurableWaitForAllError;
-class DurableSleepError extends Error {
+exports.MeshFlowWaitForAllError = MeshFlowWaitForAllError;
+class MeshFlowSleepError extends Error {
     constructor(params) {
         super(`SleepFor Interruption`);
         this.duration = params.duration;
         this.workflowId = params.workflowId;
         this.index = params.index;
         this.workflowDimension = params.workflowDimension;
-        this.code = enums_1.HMSH_CODE_DURABLE_SLEEP;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_SLEEP;
     }
 }
-exports.DurableSleepError = DurableSleepError;
-class DurableTimeoutError extends Error {
+exports.MeshFlowSleepError = MeshFlowSleepError;
+class MeshFlowTimeoutError extends Error {
     constructor(message, stack) {
         super(message);
         if (this.stack) {
             this.stack = stack;
         }
-        this.code = enums_1.HMSH_CODE_DURABLE_TIMEOUT;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_TIMEOUT;
     }
 }
-exports.DurableTimeoutError = DurableTimeoutError;
-class DurableMaxedError extends Error {
+exports.MeshFlowTimeoutError = MeshFlowTimeoutError;
+class MeshFlowMaxedError extends Error {
     constructor(message, stackTrace) {
         super(message);
         if (stackTrace) {
             this.stack = stackTrace;
         }
-        this.code = enums_1.HMSH_CODE_DURABLE_MAXED;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_MAXED;
     }
 }
-exports.DurableMaxedError = DurableMaxedError;
-class DurableFatalError extends Error {
+exports.MeshFlowMaxedError = MeshFlowMaxedError;
+class MeshFlowFatalError extends Error {
     constructor(message, stackTrace) {
         super(message);
         if (stackTrace) {
             this.stack = stackTrace;
         }
-        this.code = enums_1.HMSH_CODE_DURABLE_FATAL;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_FATAL;
     }
 }
-exports.DurableFatalError = DurableFatalError;
-class DurableRetryError extends Error {
+exports.MeshFlowFatalError = MeshFlowFatalError;
+class MeshFlowRetryError extends Error {
     constructor(message, stackTrace) {
         super(message);
         if (stackTrace) {
             this.stack = stackTrace;
         }
-        this.code = enums_1.HMSH_CODE_DURABLE_RETRYABLE;
+        this.code = enums_1.HMSH_CODE_MESHFLOW_RETRYABLE;
     }
 }
-exports.DurableRetryError = DurableRetryError;
+exports.MeshFlowRetryError = MeshFlowRetryError;
 class MapDataError extends Error {
     constructor() {
         super('Error occurred while mapping data');

package/build/modules/key.d.ts

@@ -1,47 +1,10 @@
 import { KeyStoreParams, KeyType } from '../types/hotmesh';
-/**
- * Keys
- *
- * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
- * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
- * hmsh:<appid>:r: ->                                 {hash}    throttle rates {':': '23', 'topic.thing': '555'} => {':i': 'all', 'topic.thing': '555seconds'}
- * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
- * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
- * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
- * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
- * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
- * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
- * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
- * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
- * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
- * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
- * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
- * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
- * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
- * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
- * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
- * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
- * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
- */
 declare const HMNS = "hmsh";
 declare const KEYSEP = ":";
 declare const VALSEP = "::";
 declare const WEBSEP = "::";
 declare const TYPSEP = "::";
 declare class KeyService {
-    /**
-     * returns a key that can be used to access a value in the key/value store
-     * appropriate for the given key type; the keys have an implicit hierarchy
-     * and are used to organize data in the store in a tree-like structure
-     * via the use of colons as separators. The top-level entity is the hmsh manifest.
-     * This file will reveal the full scope of what is on the server (apps, versions, etc)
-     * @param namespace
-     * @param keyType
-     * @param params
-     * @returns {string}
-     */
     static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
 }
 export { KeyService, KeyType, KeyStoreParams, HMNS, KEYSEP, TYPSEP, WEBSEP, VALSEP, };

package/build/modules/key.js

@@ -3,54 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VALSEP = exports.WEBSEP = exports.TYPSEP = exports.KEYSEP = exports.HMNS = exports.KeyType = exports.KeyService = void 0;
 const hotmesh_1 = require("../types/hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
-/**
- * Keys
- *
- * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
- * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
- * hmsh:<appid>:r: ->                                 {hash}    throttle rates {':': '23', 'topic.thing': '555'} => {':i': 'all', 'topic.thing': '555seconds'}
- * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
- * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
- * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
- * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
- * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
- * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
- * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
- * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
- * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
- * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
- * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
- * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
- * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
- * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
- * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
- * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
- * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
- */
 const HMNS = 'hmsh';
 exports.HMNS = HMNS;
-const KEYSEP = ':'; //default delimiter for keys
+const KEYSEP = ':';
 exports.KEYSEP = KEYSEP;
-const VALSEP = '::'; //default delimiter for vals
+const VALSEP = '::';
 exports.VALSEP = VALSEP;
-const WEBSEP = '::'; //default delimiter for webhook vals
+const WEBSEP = '::';
 exports.WEBSEP = WEBSEP;
-const TYPSEP = '::'; //delimiter for ZSET task typing (how should a list be used?)
+const TYPSEP = '::';
 exports.TYPSEP = TYPSEP;
 class KeyService {
-    /**
-     * returns a key that can be used to access a value in the key/value store
-     * appropriate for the given key type; the keys have an implicit hierarchy
-     * and are used to organize data in the store in a tree-like structure
-     * via the use of colons as separators. The top-level entity is the hmsh manifest.
-     * This file will reveal the full scope of what is on the server (apps, versions, etc)
-     * @param namespace
-     * @param keyType
-     * @param params
-     * @returns {string}
-     */
     static mintKey(namespace, keyType, params) {
         switch (keyType) {
             case hotmesh_1.KeyType.HOTMESH:
@@ -82,16 +45,12 @@ class KeyService {
             case hotmesh_1.KeyType.SUBSCRIPTION_PATTERNS:
                 return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
             case hotmesh_1.KeyType.HOOKS:
-                //`hooks` provide the pattern to resolve a value
                 return `${namespace}:${params.appId}:hooks`;
             case hotmesh_1.KeyType.SIGNALS:
-                //`signals` provide the registry of resolved values that link back to paused jobs
                 return `${namespace}:${params.appId}:signals`;
             case hotmesh_1.KeyType.SYMKEYS:
-                //`symbol keys` provide the registry of replacement values for job keys
                 return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
             case hotmesh_1.KeyType.SYMVALS:
-                //`symbol vals` provide the registry of replacement values for job vals
                 return `${namespace}:${params.appId}:sym:vals:`;
             case hotmesh_1.KeyType.STREAMS:
                 return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;

package/build/modules/utils.d.ts

@@ -7,11 +7,15 @@ import { StreamCode, StreamStatus } from '../types/stream';
 import { SystemHealth } from '../types/quorum';
 export declare const hashOptions: (options: any) => string;
 export declare function getSystemHealth(): Promise<SystemHealth>;
-export declare function sleepFor(ms: number): Promise<unknown>;
-export declare function sleepImmediate(): Promise<void>;
 export declare function deepCopy<T>(obj: T): T;
-export declare function guid(size?: number): string;
 export declare function deterministicRandom(seed: number): number;
+export declare function guid(size?: number): string;
+export declare function sleepFor(ms: number): Promise<void>;
+export declare function sleepImmediate(): Promise<void>;
+export declare function XSleepFor(ms: number): {
+    promise: Promise<unknown>;
+    timerId: NodeJS.Timeout;
+};
 export declare function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null;
 export declare const polyfill: {
     resolveActivityType(activityType: string): string;
@@ -19,21 +23,9 @@ export declare const polyfill: {
 export declare function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null;
 export declare function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean;
 export declare function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean;
-export declare function XSleepFor(ms: number): {
-    promise: Promise<unknown>;
-    timerId: NodeJS.Timeout;
-};
 export declare function findTopKey(obj: AppTransitions, input: string): string | null;
 export declare function findSubscriptionForTrigger(obj: AppSubscriptions, value: string): string | null;
-/**
- * Get the subscription topic for the flow to which @activityId belongs.
- * TODO: resolve this value in the compiler...do not call this at runtime
- */
 export declare function getSubscriptionTopic(activityId: string, store: StoreService<RedisClient, RedisMulti>, appVID: AppVID): Promise<string | undefined>;
-/**
- * returns the 12-digit format of the iso timestamp (e.g, 202101010000); returns
- * an empty string if overridden by the user to not segment by time (infinity).
- */
 export declare function getTimeSeries(granularity: string): string;
 export declare function formatISODate(input: Date | string): string;
 export declare function getSymKey(number: number): string;