@hotmeshio/hotmesh 0.0.38 → 0.0.39

package/build/services/durable/worker.js

@@ -8,6 +8,7 @@ const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
 const search_1 = require("./search");
 const stream_1 = require("../../types/stream");
+const enums_1 = require("../../modules/enums");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
         const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
@@ -85,7 +86,7 @@ class WorkerService {
             options: config.connection.options
         };
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
-            logLevel: config.options?.logLevel ?? 'info',
+            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
             engine: { redis: redisConfig },
             workers: [
@@ -134,7 +135,7 @@ class WorkerService {
             options: config.connection.options
         };
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
-            logLevel: config.options?.logLevel ?? 'info',
+            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
             engine: { redis: redisConfig },
             workers: [{
@@ -260,7 +261,7 @@ WorkerService.getHotMesh = async (workflowTopic, config, options) => {
         return await WorkerService.instances.get(workflowTopic);
     }
     const hotMeshClient = hotmesh_1.HotMeshService.init({
-        logLevel: options?.logLevel ?? 'info',
+        logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
         appId: config.namespace ?? factory_1.APP_ID,
         engine: { redis: { ...WorkerService.connection } }
     });

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

@@ -21,6 +21,7 @@ import { RedisClient, RedisMulti } from '../../types/redis';
 import { StringAnyType } from '../../types/serializer';
 import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
+import { WorkListTaskType } from '../../types/task';
 declare class EngineService {
     namespace: string;
     apps: HotMeshApps | null;
@@ -65,7 +66,7 @@ declare class EngineService {
     interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
     scrub(jobId: string): Promise<void>;
     hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
-    hookTime(jobId: string, gId: string, activityId: string, type?: 'sleep' | 'expire' | 'interrupt'): Promise<string | void>;
+    hookTime(jobId: string, gId: string, activityId: string, type?: WorkListTaskType): Promise<string | void>;
     hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     pub(topic: string, data: JobData, context?: JobState): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;

package/build/services/engine/index.js

@@ -304,11 +304,11 @@ class EngineService {
             }
             else if (emit) {
                 streamData.status = stream_1.StreamStatus.PENDING;
-                streamData.code = enums_1.STATUS_CODE_PENDING;
+                streamData.code = enums_1.HMSH_CODE_PENDING;
             }
             else {
                 streamData.status = stream_1.StreamStatus.SUCCESS;
-                streamData.code = enums_1.STATUS_CODE_SUCCESS;
+                streamData.code = enums_1.HMSH_CODE_SUCCESS;
             }
             return (await this.router?.publishMessage(null, streamData));
         }
@@ -361,7 +361,6 @@ class EngineService {
         else if (type === 'expire') {
             return await this.store.expireJob(jobId, 1);
         }
-        //'sleep': parse the activityId into parts
         const [aid, ...dimensions] = activityId.split(',');
         const dad = `,${dimensions.join(',')}`;
         const streamData = {
@@ -430,7 +429,7 @@ class EngineService {
         return await this.subscribe.punsubscribe(key_1.KeyType.QUORUM, this.appId, wild);
     }
     //publish and await (returns the job and data (if ready)); throws error with jobid if not
-    async pubsub(topic, data, context, timeout = enums_1.OTT_WAIT_TIME) {
+    async pubsub(topic, data, context, timeout = enums_1.HMSH_OTT_WAIT_TIME) {
         context = {
             metadata: {
                 ngn: this.guid,
@@ -453,9 +452,10 @@ class EngineService {
                 }
             });
             setTimeout(() => {
+                //note: job is still active (the subscriber timed out)
                 this.delistJobCallback(jobId);
                 reject({
-                    code: enums_1.STATUS_CODE_TIMEOUT,
+                    code: enums_1.HMSH_CODE_TIMEOUT,
                     message: 'timeout',
                     job_id: jobId
                 });
@@ -526,7 +526,7 @@ class EngineService {
      * it will be expired immediately.
      */
     resolveExpires(context, options) {
-        return options.expire ?? context.metadata.expire ?? enums_1.DURABLE_EXPIRE_SECONDS;
+        return options.expire ?? context.metadata.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS;
     }
     // ****** GET JOB STATE/COLLATION STATUS BY ID *********
     async getStatus(jobId) {

package/build/services/router/index.js

@@ -17,8 +17,8 @@ class Router {
         this.topic = config.topic;
         this.stream = stream;
         this.store = store;
-        this.reclaimDelay = config.reclaimDelay || enums_1.XCLAIM_DELAY_MS;
-        this.reclaimCount = config.reclaimCount || enums_1.XCLAIM_COUNT;
+        this.reclaimDelay = config.reclaimDelay || enums_1.HMSH_XCLAIM_DELAY_MS;
+        this.reclaimCount = config.reclaimCount || enums_1.HMSH_XCLAIM_COUNT;
         this.logger = logger;
     }
     async createGroup(stream, group) {
@@ -48,7 +48,9 @@ class Router {
                 return;
             }
             try {
-                const result = await this.stream.xreadgroup('GROUP', group, consumer, 'BLOCK', enums_1.BLOCK_TIME_MS, 'STREAMS', stream, '>');
+                //randomizer that asymptotes at 150% of `HMSH_BLOCK_TIME_MS`
+                const streamDuration = enums_1.HMSH_BLOCK_TIME_MS + Math.round((enums_1.HMSH_BLOCK_TIME_MS * Math.random()));
+                const result = await this.stream.xreadgroup('GROUP', group, consumer, 'BLOCK', streamDuration, 'STREAMS', stream, '>');
                 if (this.isStreamMessage(result)) {
                     const [[, messages]] = result;
                     for (const [id, message] of messages) {
@@ -70,7 +72,7 @@ class Router {
                 if (this.shouldConsume && process.env.NODE_ENV !== 'test') {
                     this.logger.error(`stream-consume-message-error`, { err, stream, group, consumer });
                     this.errorCount++;
-                    const timeout = Math.min(enums_1.GRADUATED_INTERVAL_MS * (2 ** this.errorCount), enums_1.MAX_TIMEOUT_MS);
+                    const timeout = Math.min(enums_1.HMSH_GRADUATED_INTERVAL_MS * (2 ** this.errorCount), enums_1.HMSH_MAX_TIMEOUT_MS);
                     setTimeout(consume.bind(this), timeout);
                 }
             }
@@ -90,7 +92,7 @@ class Router {
             telemetry.startStreamSpan(input, this.role);
             output = await this.execStreamLeg(input, stream, id, callback.bind(this));
             if (output?.status === stream_1.StreamStatus.ERROR) {
-                telemetry.setStreamError(`Function Status Code ${output.code || enums_1.STATUS_CODE_UNKNOWN}`);
+                telemetry.setStreamError(`Function Status Code ${output.code || enums_1.HMSH_CODE_UNKNOWN}`);
             }
             this.errorCount = 0;
         }
@@ -153,7 +155,7 @@ class Router {
         const errorCode = output.code.toString();
         const policy = policies?.[errorCode];
         const maxRetries = policy?.[0];
-        const tryCount = Math.min(input.metadata.try || 0, enums_1.MAX_RETRIES);
+        const tryCount = Math.min(input.metadata.try || 0, enums_1.HMSH_MAX_RETRIES);
         //only possible values for maxRetries are 1, 2, 3
         //only possible values for tryCount are 0, 1, 2
         if (maxRetries > tryCount) {
@@ -168,7 +170,7 @@ class Router {
             error.message = err.message;
         }
         else {
-            error.message = enums_1.STATUS_MESSAGE_UNKNOWN;
+            error.message = enums_1.HMSH_STATUS_UNKNOWN;
         }
         if (typeof err.stack === 'string') {
             error.stack = err.stack;
@@ -178,14 +180,14 @@ class Router {
         }
         return {
             status: 'error',
-            code: enums_1.STATUS_CODE_UNKNOWN,
+            code: enums_1.HMSH_CODE_UNKNOWN,
             metadata: { ...input.metadata, guid: (0, utils_1.guid)() },
             data: error
         };
     }
     structureUnacknowledgedError(input) {
         const message = 'stream message max delivery count exceeded';
-        const code = enums_1.STATUS_CODE_UNACKED;
+        const code = enums_1.HMSH_CODE_UNACKED;
         const data = { message, code };
         const output = {
             metadata: { ...input.metadata, guid: (0, utils_1.guid)() },
@@ -198,9 +200,9 @@ class Router {
         return output;
     }
     structureError(input, output) {
-        const message = output.data?.message ? output.data?.message.toString() : enums_1.STATUS_MESSAGE_UNKNOWN;
+        const message = output.data?.message ? output.data?.message.toString() : enums_1.HMSH_STATUS_UNKNOWN;
         const statusCode = output.code || output.data?.code;
-        const code = isNaN(statusCode) ? enums_1.STATUS_CODE_UNKNOWN : parseInt(statusCode.toString());
+        const code = isNaN(statusCode) ? enums_1.HMSH_CODE_UNKNOWN : parseInt(statusCode.toString());
         const data = { message, code };
         if (typeof output.data?.error === 'object') {
             data.error = { ...output.data.error };
@@ -216,7 +218,7 @@ class Router {
         for (const instance of [...Router.instances]) {
             instance.stopConsuming();
         }
-        await (0, utils_1.sleepFor)(enums_1.BLOCK_TIME_MS);
+        await (0, utils_1.sleepFor)(enums_1.HMSH_BLOCK_TIME_MS * 2);
     }
     async stopConsuming() {
         this.shouldConsume = false;
@@ -236,7 +238,7 @@ class Router {
         this.throttle = delayInMillis;
         this.logger.info(`stream-throttle-reset`, { delay: this.throttle, topic: this.topic });
     }
-    async claimUnacknowledged(stream, group, consumer, idleTimeMs = this.reclaimDelay, limit = enums_1.XPENDING_COUNT) {
+    async claimUnacknowledged(stream, group, consumer, idleTimeMs = this.reclaimDelay, limit = enums_1.HMSH_XPENDING_COUNT) {
         let pendingMessages = [];
         const pendingMessagesInfo = await this.stream.xpending(stream, group, '-', '+', limit); //[[ '1688768134881-0', 'testConsumer1', 1017, 1 ]]
         for (const pendingMessageInfo of pendingMessagesInfo) {
@@ -265,7 +267,7 @@ class Router {
         //     ii) corrupt hardware/network/transport/etc
         // 3b) system error: Redis unable to accept `xadd` request
         // 4c) system error: Redis unable to accept `xdel`/`xack` request
-        this.logger.error('stream-message-max-delivery-count-exceeded', { id, stream, group, consumer, code: enums_1.STATUS_CODE_UNACKED, count });
+        this.logger.error('stream-message-max-delivery-count-exceeded', { id, stream, group, consumer, code: enums_1.HMSH_CODE_UNACKED, count });
         const streamData = reclaimedMessage[0]?.[1]?.[1];
         //fatal risk point 1 of 3): json is corrupt
         const [err, input] = this.parseStreamData(streamData);

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

@@ -11,6 +11,7 @@ import { IdsData, JobStatsRange, StatsType } from '../../types/stats';
 import { Transitions } from '../../types/transition';
 import { ReclaimedMessageType } from '../../types/stream';
 import { JobCompletionOptions, JobInterruptOptions } from '../../types/job';
+import { WorkListTaskType } from '../../types/task';
 interface AbstractRedisClient {
     exec(): any;
 }
@@ -62,12 +63,16 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     activateAppVersion(id: string, version: string): Promise<boolean>;
     registerAppVersion(appId: string, version: string): Promise<any>;
     /**
-     * Registers jobId with the originJobId that spawned it. In the future,
-     * when originJobId is interrupted or expired, the items in the
-     * list (added via RPUSH) are LPOPed. If origin was expired, then
-     * LPOPed items from the list are likewise expired;
+     * Registers the job, `jobId`, with `originJobId`. In the future,
+     * when `originJobId` is interrupted/expired, the items in the
+     * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    setDependency(originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
+    registerJobDependency(originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
+    /**
+     * Ensures a `hook signal` is delisted when its parent activity/job
+     * is interrupted/expired.
+     */
+    registerSignalDependency(jobId: string, signalKey: string, multi?: U): Promise<any>;
     setStats(jobKey: string, jobId: string, dateTime: string, stats: StatsType, appVersion: AppVID, multi?: U): Promise<any>;
     hGetAllResult(result: any): any;
     getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
@@ -106,15 +111,15 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * expired at a future date; options indicate whether this
      * is a standard `expire` or an `interrupt`
      */
-    registerExpireJob(jobId: string, deletionTime: number, options: JobCompletionOptions): Promise<void>;
+    registerDependenciesForCleanup(jobId: string, deletionTime: number, options: JobCompletionOptions): Promise<void>;
     /**
      * registers a hook activity to be awakened (uses ZSET to
      * store the 'sleep group' and LIST to store the events
      * for the given sleep group. Sleep groups are
      * organized into 'n'-second blocks (LISTS))
      */
-    registerTimeHook(jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt', deletionTime: number, multi?: U): Promise<void>;
-    getNextTimeJob(listKey?: string): Promise<[listKey: string, jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt'] | boolean>;
+    registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, deletionTime: number, multi?: U): Promise<void>;
+    getNextTask(listKey?: string): Promise<[listKey: string, jobId: string, gId: string, activityId: string, type: WorkListTaskType] | boolean>;
     /**
      * when processing time jobs, the target LIST ID returned
      * from the ZSET query can be prefixed to denote what to
@@ -123,7 +128,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * generic LIST (lists typically contain target job ids)
      * @param {string} listKey - for example `::INTERRUPT::job123` or `job123`
      */
-    resolveKeyContext(listKey: string): [('sleep' | 'expire' | 'interrupt'), string];
+    resolveTaskKeyContext(listKey: string): [('sleep' | 'expire' | 'interrupt' | 'delist'), string];
     /**
      * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
      * This method is called by the engine and not by an activity and is

package/build/services/store/index.js

@@ -104,7 +104,7 @@ class StoreService {
      * check for and process work items in the
      * time and signal task queues.
      */
-    async reserveScoutRole(scoutType, delay = enums_1.SCOUT_INTERVAL_SECONDS) {
+    async reserveScoutRole(scoutType, delay = enums_1.HMSH_SCOUT_INTERVAL_SECONDS) {
         const key = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId, scoutType });
         const success = await this.redisClient[this.commands.setnx](key, `${scoutType}:${(0, utils_1.formatISODate)(new Date())}`);
         if (this.isSuccessful(success)) {
@@ -308,16 +308,35 @@ class StoreService {
         return await this.redisClient[this.commands.hset](key, payload);
     }
     /**
-     * Registers jobId with the originJobId that spawned it. In the future,
-     * when originJobId is interrupted or expired, the items in the
-     * list (added via RPUSH) are LPOPed. If origin was expired, then
-     * LPOPed items from the list are likewise expired;
+     * Registers the job, `jobId`, with `originJobId`. In the future,
+     * when `originJobId` is interrupted/expired, the items in the
+     * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    async setDependency(originJobId, topic, jobId, gId, multi) {
+    async registerJobDependency(originJobId, topic, jobId, gId, multi) {
         const privateMulti = multi || this.getMulti();
-        const depParams = { appId: this.appId, jobId: originJobId };
-        const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
-        privateMulti[this.commands.rpush](depKey, `expire::${topic}::${gId}::${jobId}`);
+        const dependencyParams = {
+            appId: this.appId,
+            jobId: originJobId,
+        };
+        const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, dependencyParams);
+        //tasks have '4' segments
+        const expireTask = `expire::${topic}::${gId}::${jobId}`;
+        privateMulti[this.commands.rpush](depKey, expireTask);
+        if (!multi) {
+            return await privateMulti.exec();
+        }
+    }
+    /**
+     * Ensures a `hook signal` is delisted when its parent activity/job
+     * is interrupted/expired.
+     */
+    async registerSignalDependency(jobId, signalKey, multi) {
+        const privateMulti = multi || this.getMulti();
+        const dependencyParams = { appId: this.appId, jobId };
+        const dependencyKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, dependencyParams);
+        //tasks have '4' segments
+        const delistTask = `delist::signal::${jobId}::${signalKey}`;
+        privateMulti[this.commands.rpush](dependencyKey, delistTask);
         if (!multi) {
             return await privateMulti.exec();
         }
@@ -612,11 +631,11 @@ class StoreService {
     }
     async setHookSignal(hook, multi) {
         const key = this.mintKey(key_1.KeyType.SIGNALS, { appId: this.appId });
-        const { topic, resolved, jobId } = hook;
-        const payload = {
-            [`${topic}:${resolved}`]: jobId
-        };
-        return await (multi || this.redisClient)[this.commands.hset](key, payload);
+        const { topic, resolved, jobId } = hook; //`${activityId}::${dad}::${gId}::${jobId}`
+        const signalKey = `${topic}:${resolved}`;
+        const payload = { [signalKey]: jobId };
+        await (multi || this.redisClient)[this.commands.hset](key, payload);
+        return await this.registerSignalDependency(jobId.split('::')[3], signalKey, multi);
     }
     async getHookSignal(topic, resolved) {
         const key = this.mintKey(key_1.KeyType.SIGNALS, { appId: this.appId });
@@ -677,7 +696,7 @@ class StoreService {
      * expired at a future date; options indicate whether this
      * is a standard `expire` or an `interrupt`
      */
-    async registerExpireJob(jobId, deletionTime, options) {
+    async registerDependenciesForCleanup(jobId, deletionTime, options) {
         const depParams = { appId: this.appId, jobId };
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
         const context = options.interrupt ? 'INTERRUPT' : 'EXPIRE';
@@ -700,21 +719,25 @@ class StoreService {
             await this.zAdd(zsetKey, deletionTime.toString(), listKey, multi);
         }
     }
-    async getNextTimeJob(listKey) {
-        const existing = Boolean(listKey);
+    async getNextTask(listKey) {
         const zsetKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId });
         listKey = listKey || await this.zRangeByScore(zsetKey, 0, Date.now());
         if (listKey) {
-            const [pType, pKey] = this.resolveKeyContext(listKey);
+            let [pType, pKey] = this.resolveTaskKeyContext(listKey);
             const timeEvent = await this.redisClient[this.commands.lpop](pKey);
             if (timeEvent) {
-                //there are 3 time-related event triggers: sleep, expire, interrupt
-                const [_type, activityId, gId, ...jobId] = timeEvent.split('::');
+                //there are 4 time-related task
+                //1) sleep (awaken), 2) expire, 3) interrupt, 4) delist
+                const [type, activityId, gId, ...jobId] = timeEvent.split('::');
+                if (type === 'delist') {
+                    pType = 'delist';
+                }
                 return [listKey, jobId.join('::'), gId, activityId, pType];
             }
             await this.redisClient[this.commands.zrem](zsetKey, listKey);
+            return true;
         }
-        return existing;
+        return false;
     }
     /**
      * when processing time jobs, the target LIST ID returned
@@ -724,7 +747,7 @@ class StoreService {
      * generic LIST (lists typically contain target job ids)
      * @param {string} listKey - for example `::INTERRUPT::job123` or `job123`
      */
-    resolveKeyContext(listKey) {
+    resolveTaskKeyContext(listKey) {
         if (listKey.startsWith('::INTERRUPT')) {
             return ['interrupt', listKey.split('::')[2]];
         }
@@ -766,7 +789,7 @@ class StoreService {
                 this.serializer.resetSymbols(symKeys, symVals, {});
                 //persists the standard 410 error (job is `gone`)
                 const err = JSON.stringify({
-                    code: enums_1.STATUS_CODE_INTERRUPT,
+                    code: enums_1.HMSH_CODE_INTERRUPT,
                     message: options.reason ?? `job [${jobId}] interrupted`,
                     job_id: jobId
                 });

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/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;
+;