@hotmeshio/hotmesh 0.0.37 → 0.0.39

package/build/services/stream/clients/ioredis.js

@@ -25,18 +25,18 @@ class IORedisStreamService extends index_1.StreamService {
             try {
                 return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
             }
-            catch (err) {
+            catch (error) {
                 this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
-                throw err;
+                throw error;
             }
         }
         else {
             try {
                 return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
             }
-            catch (err) {
+            catch (error) {
                 this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
-                throw err;
+                throw error;
             }
         }
     }
@@ -44,9 +44,9 @@ class IORedisStreamService extends index_1.StreamService {
         try {
             return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
         }
-        catch (err) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { error });
+            throw error;
         }
     }
     async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
@@ -56,9 +56,9 @@ class IORedisStreamService extends index_1.StreamService {
             // @ts-ignore
             blockOption, blockTime, streamsOption, streamName, id);
         }
-        catch (err) {
-            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { error });
+            throw error;
         }
     }
     async xpending(key, group, start, end, count, consumer) {
@@ -75,40 +75,49 @@ class IORedisStreamService extends index_1.StreamService {
             try {
                 return await this.redisClient.call('XPENDING', ...args);
             }
-            catch (err) {
-                this.logger.error('err, args', err, args);
+            catch (error) {
+                this.logger.error('err, args', { error }, args);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, { error });
+            throw error;
         }
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
             return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
         }
-        catch (err) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xack(key, group, id, multi) {
         try {
             return await (multi || this.redisClient).xack(key, group, id);
         }
-        catch (err) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xdel(key, id, multi) {
         try {
             return await (multi || this.redisClient).xdel(key, id);
         }
-        catch (err) {
-            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async xlen(key, multi) {
+        try {
+            return await (multi || this.redisClient).xlen(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting stream depth: ${key}`, { error });
+            throw error;
         }
     }
 }

package/build/services/stream/clients/redis.d.ts

@@ -19,5 +19,6 @@ declare class RedisStreamService extends StreamService<RedisClientType, RedisMul
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
     xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
     xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xlen(key: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
 }
 export { RedisStreamService };

package/build/services/stream/clients/redis.js

@@ -115,5 +115,20 @@ class RedisStreamService extends index_1.StreamService {
             throw err;
         }
     }
+    async xlen(key, multi) {
+        try {
+            if (multi) {
+                multi.XLEN(key);
+                return multi;
+            }
+            else {
+                return await this.redisClient.XLEN(key);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error getting stream depth: ${key}`, { error });
+            throw error;
+        }
+    }
 }
 exports.RedisStreamService = RedisStreamService;

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

@@ -17,5 +17,6 @@ declare abstract class StreamService<T, U> {
     abstract xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
     abstract xack(key: string, group: string, id: string, multi?: U): Promise<number | U>;
     abstract xdel(key: string, id: string, multi?: U): Promise<number | U>;
+    abstract xlen(key: string, multi?: U): Promise<number | U>;
 }
 export { StreamService };

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

@@ -4,6 +4,7 @@ import { StoreService } from '../store';
 import { HookInterface, HookRule } from '../../types/hook';
 import { JobCompletionOptions, JobState } from '../../types/job';
 import { RedisClient, RedisMulti } from '../../types/redis';
+import { WorkListTaskType } from '../../types/task';
 declare class TaskService {
     store: StoreService<RedisClient, RedisMulti>;
     logger: ILogger;
@@ -13,12 +14,18 @@ declare class TaskService {
     processWebHooks(hookEventCallback: HookInterface): Promise<void>;
     enqueueWorkItems(keys: string[]): Promise<void>;
     registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions): Promise<void>;
-    registerTimeHook(jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt', inSeconds?: number, multi?: RedisMulti): Promise<void>;
+    registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, inSeconds?: number, multi?: RedisMulti): Promise<void>;
     /**
-     * Should this engine instance play the role of 'scout' for the quorum.
+     * Should this engine instance play the role of 'scout' on behalf
+     * of the entire quorum? The scout role is responsible for processing
+     * task lists on behalf of the collective.
      */
     shouldScout(): Promise<boolean>;
-    processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt') => Promise<void>, listKey?: string): Promise<void>;
+    /**
+     * Callback handler that takes an item from a work list and
+     * processes according to its type
+     */
+    processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: WorkListTaskType) => Promise<void>, listKey?: string): Promise<void>;
     cancelCleanup(): void;
     getHookRule(topic: string): Promise<HookRule | undefined>;
     registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string>;

package/build/services/task/index.js

@@ -4,6 +4,7 @@ exports.TaskService = void 0;
 const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
 const pipe_1 = require("../pipe");
+const hotmesh_1 = require("../../types/hotmesh");
 class TaskService {
     constructor(store, logger) {
         this.cleanupTimeout = null;
@@ -31,19 +32,25 @@ class TaskService {
     async enqueueWorkItems(keys) {
         await this.store.addTaskQueues(keys);
     }
-    async registerJobForCleanup(jobId, inSeconds = enums_1.EXPIRE_DURATION, options) {
+    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options) {
         if (inSeconds > 0) {
             await this.store.expireJob(jobId, inSeconds);
-            const expireTimeSlot = Math.floor((Date.now() + (inSeconds * 1000)) / (enums_1.FIDELITY_SECONDS * 1000)) * (enums_1.FIDELITY_SECONDS * 1000); //n second awaken groups
-            await this.store.registerExpireJob(jobId, expireTimeSlot, options);
+            const fromNow = Date.now() + (inSeconds * 1000);
+            const fidelityMS = enums_1.HMSH_FIDELITY_SECONDS * 1000;
+            const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+            await this.store.registerDependenciesForCleanup(jobId, timeSlot, options);
         }
     }
-    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.FIDELITY_SECONDS, multi) {
-        const awakenTimeSlot = Math.floor((Date.now() + (inSeconds * 1000)) / (enums_1.FIDELITY_SECONDS * 1000)) * (enums_1.FIDELITY_SECONDS * 1000); //n second awaken groups
+    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, multi) {
+        const fromNow = Date.now() + (inSeconds * 1000);
+        const fidelityMS = enums_1.HMSH_FIDELITY_SECONDS * 1000;
+        const awakenTimeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
         await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, multi);
     }
     /**
-     * Should this engine instance play the role of 'scout' for the quorum.
+     * Should this engine instance play the role of 'scout' on behalf
+     * of the entire quorum? The scout role is responsible for processing
+     * task lists on behalf of the collective.
      */
     async shouldScout() {
         const wasScout = this.isScout;
@@ -52,31 +59,42 @@ class TaskService {
             if (!wasScout) {
                 setTimeout(() => {
                     this.isScout = false;
-                }, enums_1.SCOUT_INTERVAL_SECONDS * 1000);
+                }, enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000);
             }
             return true;
         }
         return false;
     }
+    /**
+     * Callback handler that takes an item from a work list and
+     * processes according to its type
+     */
     async processTimeHooks(timeEventCallback, listKey) {
         if (await this.shouldScout()) {
             try {
-                const timeJob = await this.store.getNextTimeJob(listKey);
-                if (Array.isArray(timeJob)) {
-                    //a queue had a job; try again immediately
-                    const [listKey, jobId, gId, activityId, type] = timeJob;
-                    await timeEventCallback(jobId, gId, activityId, type);
+                const workListTask = await this.store.getNextTask(listKey);
+                if (Array.isArray(workListTask)) {
+                    const [listKey, target, gId, activityId, type] = workListTask;
+                    if (type === 'delist') {
+                        //delist the signalKey (target)
+                        const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, { appId: this.store.appId });
+                        await this.store.redisClient[this.store.commands.hdel](key, target);
+                    }
+                    else {
+                        //awaken/expire/interrupt
+                        await timeEventCallback(target, gId, activityId, type);
+                    }
                     await (0, utils_1.sleepFor)(0);
                     this.processTimeHooks(timeEventCallback, listKey);
                 }
-                else if (timeJob) {
-                    //a queue was just emptied; try again immediately
+                else if (workListTask) {
+                    //a worklist was just emptied; try again immediately
                     await (0, utils_1.sleepFor)(0);
                     this.processTimeHooks(timeEventCallback);
                 }
                 else {
-                    //all queues are empty; sleep before checking
-                    let sleep = (0, utils_1.XSleepFor)(enums_1.FIDELITY_SECONDS * 1000);
+                    //no worklists exist; sleep before checking
+                    let sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_FIDELITY_SECONDS * 1000);
                     this.cleanupTimeout = sleep.timerId;
                     await sleep.promise;
                     this.processTimeHooks(timeEventCallback);
@@ -89,7 +107,7 @@ class TaskService {
         }
         else {
             //didn't get the scout role; try again in 'one-ish' minutes
-            let sleep = (0, utils_1.XSleepFor)(enums_1.SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
+            let sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
             this.cleanupTimeout = sleep.timerId;
             await sleep.promise;
             this.processTimeHooks(timeEventCallback);

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

@@ -25,6 +25,7 @@ declare class WorkerService {
     initStreamChannel(service: WorkerService, stream: RedisClient): Promise<void>;
     initRouter(worker: HotMeshWorker, logger: ILogger): Router;
     subscriptionHandler(): SubscriptionCallback;
+    sayPong(appId: string, guid: string, originator: string, details?: boolean): Promise<void>;
     throttle(delayInMillis: number): Promise<void>;
 }
 export { WorkerService };

package/build/services/worker/index.js

@@ -96,8 +96,32 @@ class WorkerService {
             if (message.type === 'throttle') {
                 self.throttle(message.throttle);
             }
+            else if (message.type === 'ping') {
+                self.sayPong(self.appId, self.guid, message.originator, message.details);
+            }
         };
     }
+    async sayPong(appId, guid, originator, details = false) {
+        let profile;
+        if (details) {
+            const params = {
+                appId: this.appId,
+                topic: this.topic,
+            };
+            profile = {
+                engine_id: this.guid,
+                namespace: this.namespace,
+                app_id: this.appId,
+                worker_topic: this.topic,
+                stream: this.stream.mintKey(key_1.KeyType.STREAMS, params),
+            };
+        }
+        this.store.publish(key_1.KeyType.QUORUM, {
+            type: 'pong',
+            guid, originator,
+            profile,
+        }, appId);
+    }
     async throttle(delayInMillis) {
         this.router.setThrottle(delayInMillis);
     }

package/build/types/durable.d.ts

@@ -1,3 +1,4 @@
+import { LogLevel } from './logger';
 import { RedisClass, RedisOptions } from './redis';
 type WorkflowConfig = {
     backoffCoefficient?: number;
@@ -151,12 +152,12 @@ type MeshOSActivityOptions = {
 type MeshOSWorkerOptions = {
     taskQueue?: string;
     allowList?: Array<MeshOSOptions | string>;
-    logLevel?: string;
+    logLevel?: LogLevel;
     maxSystemRetries?: number;
     backoffCoefficient?: number;
 };
 type WorkerOptions = {
-    logLevel?: string;
+    logLevel?: LogLevel;
     maxSystemRetries?: number;
     backoffCoefficient?: number;
 };

package/build/types/hotmesh.d.ts

@@ -3,6 +3,47 @@ import { HotMeshService } from '../services/hotmesh';
 import { HookRules } from './hook';
 import { RedisClass, RedisClient, RedisOptions } from './redis';
 import { StreamData, StreamDataResponse } from './stream';
+import { LogLevel } from './logger';
+/**
+ * the full set of entity types that are stored in the key/value store
+ */
+declare enum KeyType {
+    APP = "APP",
+    ENGINE_ID = "ENGINE",
+    HOOKS = "HOOKS",
+    JOB_DEPENDENTS = "JOB_DEPENDENTS",
+    JOB_STATE = "JOB_STATE",
+    JOB_STATS_GENERAL = "JOB_STATS_GENERAL",
+    JOB_STATS_MEDIAN = "JOB_STATS_MEDIAN",
+    JOB_STATS_INDEX = "JOB_STATS_INDEX",
+    HOTMESH = "HOTMESH",
+    QUORUM = "QUORUM",
+    SCHEMAS = "SCHEMAS",
+    SIGNALS = "SIGNALS",
+    STREAMS = "STREAMS",
+    SUBSCRIPTIONS = "SUBSCRIPTIONS",
+    SUBSCRIPTION_PATTERNS = "SUBSCRIPTION_PATTERNS",
+    SYMKEYS = "SYMKEYS",
+    SYMVALS = "SYMVALS",
+    TIME_RANGE = "TIME_RANGE",
+    WORK_ITEMS = "WORK_ITEMS"
+}
+/**
+ * minting keys, requires one or more of the following parameters
+ */
+type KeyStoreParams = {
+    appId?: string;
+    engineId?: string;
+    appVersion?: string;
+    jobId?: string;
+    activityId?: string;
+    jobKey?: string;
+    dateTime?: string;
+    facet?: string;
+    topic?: string;
+    timeValue?: number;
+    scoutType?: 'signal' | 'time';
+};
 type HotMesh = typeof HotMeshService;
 type RedisConfig = {
     class: RedisClass;
@@ -34,7 +75,7 @@ type HotMeshConfig = {
     namespace?: string;
     name?: string;
     logger?: ILogger;
-    logLevel?: 'silly' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    logLevel?: LogLevel;
     engine?: HotMeshEngine;
     workers?: HotMeshWorker[];
 };
@@ -79,4 +120,4 @@ type HotMeshApps = {
 export { HotMesh, HotMeshEngine, RedisConfig, HotMeshWorker, HotMeshSettings, HotMeshApp, //a single app in the db
 HotMeshApps, //object array of all apps in the db
 HotMeshConfig, //customer config
-HotMeshManifest, HotMeshGraph };
+HotMeshManifest, HotMeshGraph, KeyType, KeyStoreParams, };

package/build/types/hotmesh.js

@@ -1,2 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyType = void 0;
+/**
+ * the full set of entity types that are stored in the key/value store
+ */
+var KeyType;
+(function (KeyType) {
+    KeyType["APP"] = "APP";
+    KeyType["ENGINE_ID"] = "ENGINE";
+    KeyType["HOOKS"] = "HOOKS";
+    KeyType["JOB_DEPENDENTS"] = "JOB_DEPENDENTS";
+    KeyType["JOB_STATE"] = "JOB_STATE";
+    KeyType["JOB_STATS_GENERAL"] = "JOB_STATS_GENERAL";
+    KeyType["JOB_STATS_MEDIAN"] = "JOB_STATS_MEDIAN";
+    KeyType["JOB_STATS_INDEX"] = "JOB_STATS_INDEX";
+    KeyType["HOTMESH"] = "HOTMESH";
+    KeyType["QUORUM"] = "QUORUM";
+    KeyType["SCHEMAS"] = "SCHEMAS";
+    KeyType["SIGNALS"] = "SIGNALS";
+    KeyType["STREAMS"] = "STREAMS";
+    KeyType["SUBSCRIPTIONS"] = "SUBSCRIPTIONS";
+    KeyType["SUBSCRIPTION_PATTERNS"] = "SUBSCRIPTION_PATTERNS";
+    KeyType["SYMKEYS"] = "SYMKEYS";
+    KeyType["SYMVALS"] = "SYMVALS";
+    KeyType["TIME_RANGE"] = "TIME_RANGE";
+    KeyType["WORK_ITEMS"] = "WORK_ITEMS";
+})(KeyType || (KeyType = {}));
+exports.KeyType = KeyType;
+;

package/build/types/index.d.ts

@@ -10,12 +10,13 @@ export { ILogger } from './logger';
 export { JobData, JobsData, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState } from './job';
 export { MappingStatements } from './map';
 export { Pipe, PipeItem, PipeItems } from './pipe';
-export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker } from './hotmesh';
-export { ActivateMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, SubscriptionCallback, ThrottleMessage, WorkMessage } from './quorum';
+export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker, KeyStoreParams, KeyType } from './hotmesh';
+export { ActivateMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, SubscriptionCallback, ThrottleMessage, WorkMessage } from './quorum';
 export { MultiResponseFlags, RedisClient, RedisMulti } from './redis';
 export { RedisClientType, RedisMultiType } from './redisclient';
 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/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var ioredisclient_1 = require("./ioredisclient");
 Object.defineProperty(exports, "IORedisClientType", { enumerable: true, get: function () { return ioredisclient_1.RedisClientType; } });
+var hotmesh_1 = require("./hotmesh");
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });

package/build/types/logger.d.ts

@@ -4,3 +4,4 @@ export interface ILogger {
     warn(message: string, ...meta: any[]): void;
     debug(message: string, ...meta: any[]): void;
 }
+export type LogLevel = 'silly' | 'debug' | 'info' | 'warn' | 'error' | 'silent';

package/build/types/logger.js

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

package/build/types/quorum.d.ts

@@ -1,7 +1,16 @@
 import { JobOutput } from "./job";
+export interface QuorumProfile {
+    namespace: string;
+    app_id: string;
+    engine_id: string;
+    worker_topic?: string;
+    stream?: string;
+    stream_depth?: number;
+}
 export interface PingMessage {
     type: 'ping';
     originator: string;
+    details?: boolean;
 }
 export interface WorkMessage {
     type: 'work';
@@ -13,8 +22,9 @@ export interface CronMessage {
 }
 export interface PongMessage {
     type: 'pong';
-    originator: string;
     guid: string;
+    originator: string;
+    profile?: QuorumProfile;
 }
 export interface ActivateMessage {
     type: 'activate';

package/build/types/redisclient.d.ts

@@ -4,6 +4,7 @@ interface RedisMultiType {
     XADD(key: string, id: string, fields: any): this;
     XACK(key: string, group: string, id: string): this;
     XDEL(key: string, id: string): this;
+    XLEN(key: string): this;
     HDEL(key: string, itemId: string): this;
     HGET(key: string, itemId: string): this;
     HGETALL(key: string): this;

package/build/types/task.d.ts

@@ -0,0 +1 @@
+export type WorkListTaskType = 'sleep' | 'expire' | 'interrupt' | 'delist';

package/build/types/task.js

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

package/modules/enums.ts

@@ -1,35 +1,49 @@
-// Engine Constants
-export const STATUS_CODE_SUCCESS = 200;
-export const STATUS_CODE_PENDING = 202;
-export const STATUS_CODE_TIMEOUT = 504;
-export const STATUS_CODE_INTERRUPT = 410;
-export const OTT_WAIT_TIME = 1000;
-
-// Stream Constants
-export const MAX_RETRIES = 3; //local retry; 10, 100, 1000ms
-export const MAX_TIMEOUT_MS = 60000;
-export const GRADUATED_INTERVAL_MS = 5000;
-
-export const BLOCK_DURATION = 15000; //Set to `15` so SIGINT/SIGTERM can interrupt; set to `0` to BLOCK indefinitely
-export const TEST_BLOCK_DURATION = 1000; //Set to `1000` so tests can interrupt quickly
-export const BLOCK_TIME_MS = process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BLOCK_DURATION;
-
-export const XCLAIM_DELAY_MS = 1000 * 60; //max time a message can be unacked before it is claimed by another
-export const XCLAIM_COUNT = 3; //max number of times a message can be claimed by another before it is dead-lettered
-export const XPENDING_COUNT = 10;
-
-export const STATUS_CODE_UNACKED = 999;
-export const STATUS_CODE_UNKNOWN = 500;
-export const STATUS_MESSAGE_UNKNOWN = 'unknown';
-
-// HotMesh Constants
-export const EXPIRE_DURATION = 15;        // default expire in seconds; once job state semaphore reaches '0', this is applied to set Redis to expire the job HASH
-export const BASE_FIDELITY_SECONDS = 15;  // granularity resolution window size
-export const TEST_FIDELITY_SECONDS = 5;
-export const FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS
-
-// DURABLE CONSTANTS
-export const DURABLE_EXPIRE_SECONDS = 1;
-
-// TASK CONSTANTS
-export const SCOUT_INTERVAL_SECONDS = 60;
+import { LogLevel } from "../types/logger";
+
+// HOTMESH SYSTEM
+export const HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL as LogLevel || 'info';
+
+// STATUS CODES AND MESSAGES
+export const HMSH_CODE_SUCCESS = 200;
+export const HMSH_CODE_PENDING = 202;
+export const HMSH_CODE_NOTFOUND = 404;
+export const HMSH_CODE_INTERRUPT = 410;
+export const HMSH_CODE_UNKNOWN = 500;
+export const HMSH_CODE_TIMEOUT = 504;
+export const HMSH_CODE_UNACKED = 999;
+
+export const HMSH_CODE_DURABLE_SLEEPFOR = 592;
+export const HMSH_CODE_DURABLE_INCOMPLETE = 593;
+export const HMSH_CODE_DURABLE_WAITFOR = 594;
+export const HMSH_CODE_DURABLE_TIMEOUT = 596;
+export const HMSH_CODE_DURABLE_MAXED = 597;
+export const HMSH_CODE_DURABLE_FATAL = 598;
+export const HMSH_CODE_DURABLE_RETRYABLE = 599;
+
+export const HMSH_STATUS_UNKNOWN = 'unknown';
+
+// ENGINE
+export const HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
+export const HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
+
+// STREAM ROUTER
+export const HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
+export const HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
+export const HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
+
+const BASE_BLOCK_DURATION = 10000; // Modified for clarity
+const TEST_BLOCK_DURATION = 1000; // Modified for clarity
+export const HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS ? parseInt(process.env.HMSH_BLOCK_TIME_MS, 10) : (process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BASE_BLOCK_DURATION);
+
+export const HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
+export const HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
+export const HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
+
+// TASK WORKER
+export const HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
+
+const BASE_FIDELITY_SECONDS = 5;
+const TEST_FIDELITY_SECONDS = 5;
+export const HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS ? parseInt(process.env.HMSH_FIDELITY_SECONDS, 10) : (process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS);
+
+export const HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;