@hotmeshio/hotmesh 0.0.37 → 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/hotmesh/index.d.ts

@@ -4,7 +4,7 @@ import { QuorumService } from '../quorum';
 import { WorkerService } from '../worker';
 import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
-import { JobMessageCallback } from '../../types/quorum';
+import { JobMessageCallback, QuorumProfile } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 import { StringAnyType } from '../../types/serializer';
@@ -31,10 +31,10 @@ declare class HotMeshService {
     punsub(wild: string): Promise<void>;
     pubsub(topic: string, data?: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
     add(streamData: StreamData | StreamDataResponse): Promise<string>;
+    rollCall(delay?: number): Promise<QuorumProfile[]>;
     plan(path: string): Promise<HotMeshManifest>;
     deploy(pathOrYAML: string): Promise<HotMeshManifest>;
     activate(version: string, delay?: number): Promise<boolean>;
-    inventory(version: string, delay?: number): Promise<number>;
     getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;

package/build/services/hotmesh/index.js

@@ -90,6 +90,9 @@ class HotMeshService {
         return await this.engine.add(streamData);
     }
     // ************* COMPILER METHODS *************
+    async rollCall(delay) {
+        return await this.quorum?.rollCall(delay);
+    }
     async plan(path) {
         return await this.engine?.plan(path);
     }
@@ -100,10 +103,6 @@ class HotMeshService {
         //activation is a quorum operation
         return await this.quorum?.activate(version, delay);
     }
-    async inventory(version, delay) {
-        //get count of all peers
-        return await this.quorum?.inventory(delay);
-    }
     // ************* REPORTER METHODS *************
     async getStats(topic, query) {
         return await this.engine?.getStats(topic, query);

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

@@ -3,15 +3,15 @@ import { ILogger } from '../logger';
 import { StoreService } from '../store';
 import { SubService } from '../sub';
 import { CacheMode } from '../../types/cache';
-import { QuorumMessageCallback, SubscriptionCallback, ThrottleMessage } from '../../types/quorum';
-import { HotMeshApps, HotMeshConfig } from '../../types/hotmesh';
+import { QuorumMessageCallback, QuorumProfile, SubscriptionCallback, ThrottleMessage } from '../../types/quorum';
+import { HotMeshConfig } from '../../types/hotmesh';
 import { RedisClient, RedisMulti } from '../../types/redis';
 declare class QuorumService {
     namespace: string;
-    apps: HotMeshApps | null;
     appId: string;
     guid: string;
     engine: EngineService;
+    profiles: QuorumProfile[];
     store: StoreService<RedisClient, RedisMulti> | null;
     subscribe: SubService<RedisClient, RedisMulti> | null;
     logger: ILogger;
@@ -24,12 +24,12 @@ declare class QuorumService {
     initStoreChannel(store: RedisClient): Promise<void>;
     initSubChannel(sub: RedisClient): Promise<void>;
     subscriptionHandler(): SubscriptionCallback;
-    sayPong(appId: string, guid: string, originator: string): Promise<void>;
-    requestQuorum(delay?: number): Promise<number>;
+    sayPong(appId: string, guid: string, originator: string, details?: boolean): Promise<void>;
+    requestQuorum(delay?: number, details?: boolean): Promise<number>;
     pub(quorumMessage: ThrottleMessage): Promise<boolean>;
     sub(callback: QuorumMessageCallback): Promise<void>;
     unsub(callback: QuorumMessageCallback): Promise<void>;
-    inventory(delay?: number): Promise<number>;
+    rollCall(delay?: number): Promise<QuorumProfile[]>;
     activate(version: string, delay?: number): Promise<boolean>;
 }
 export { QuorumService };

package/build/services/quorum/index.js

@@ -12,6 +12,7 @@ const redis_2 = require("../sub/clients/redis");
 const QUORUM_DELAY = 250;
 class QuorumService {
     constructor() {
+        this.profiles = [];
         this.cacheMode = 'cache';
         this.untilVersion = null;
         this.quorum = null;
@@ -68,10 +69,13 @@ class QuorumService {
                 self.engine.setCacheMode(message.cache_mode, message.until_version);
             }
             else if (message.type === 'ping') {
-                this.sayPong(self.appId, self.guid, message.originator);
+                self.sayPong(self.appId, self.guid, message.originator, message.details);
             }
             else if (message.type === 'pong' && self.guid === message.originator) {
                 self.quorum = self.quorum + 1;
+                if (message.profile) {
+                    self.profiles.push(message.profile);
+                }
             }
             else if (message.type === 'throttle') {
                 self.engine.throttle(message.throttle);
@@ -91,13 +95,31 @@ class QuorumService {
             }
         };
     }
-    async sayPong(appId, guid, originator) {
-        this.store.publish(key_1.KeyType.QUORUM, { type: 'pong', guid, originator }, appId);
+    async sayPong(appId, guid, originator, details = false) {
+        let profile;
+        if (details) {
+            profile = {
+                engine_id: this.guid,
+                namespace: this.namespace,
+                app_id: this.appId,
+                stream: this.engine.stream.mintKey(key_1.KeyType.STREAMS, { appId: this.appId })
+            };
+        }
+        this.store.publish(key_1.KeyType.QUORUM, {
+            type: 'pong',
+            guid, originator,
+            profile,
+        }, appId);
     }
-    async requestQuorum(delay = QUORUM_DELAY) {
+    async requestQuorum(delay = QUORUM_DELAY, details = false) {
         const quorum = this.quorum;
         this.quorum = 0;
-        await this.store.publish(key_1.KeyType.QUORUM, { type: 'ping', originator: this.guid }, this.appId);
+        this.profiles.length = 0;
+        await this.store.publish(key_1.KeyType.QUORUM, {
+            type: 'ping',
+            originator: this.guid,
+            details,
+        }, this.appId);
         await (0, utils_1.sleepFor)(delay);
         return quorum;
     }
@@ -117,12 +139,26 @@ class QuorumService {
         this.callbacks = this.callbacks.filter(cb => cb !== callback);
     }
     // ************* COMPILER METHODS *************
-    async inventory(delay = QUORUM_DELAY) {
-        await this.requestQuorum(delay);
-        const q1 = await this.requestQuorum(delay);
-        const q2 = await this.requestQuorum(delay);
-        const q3 = await this.requestQuorum(delay);
-        return Math.round((q1 + q2 + q3) / 3);
+    async rollCall(delay = QUORUM_DELAY) {
+        await this.requestQuorum(delay, true);
+        const targetStreams = [];
+        const multi = this.store.getMulti();
+        this.profiles.forEach((profile) => {
+            if (!targetStreams.includes(profile.stream)) {
+                targetStreams.push(profile.stream);
+                this.store.xlen(profile.stream, multi);
+            }
+        });
+        const stream_depths = await multi.exec();
+        this.profiles.forEach(async (profile) => {
+            const index = targetStreams.indexOf(profile.stream);
+            if (index != -1) {
+                profile.stream_depth = Array.isArray(stream_depths[index]) ?
+                    stream_depths[index][1] :
+                    stream_depths[index];
+            }
+        });
+        return this.profiles;
     }
     async activate(version, delay = QUORUM_DELAY) {
         version = version.toString();

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/clients/ioredis.d.ts

@@ -24,5 +24,6 @@ declare class IORedisStoreService extends StoreService<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 { IORedisStoreService };

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

@@ -105,5 +105,14 @@ class IORedisStoreService extends index_1.StoreService {
             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;
+        }
+    }
 }
 exports.IORedisStoreService = IORedisStoreService;

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

@@ -26,5 +26,6 @@ declare class RedisStoreService extends StoreService<RedisClientType, RedisMulti
     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 { RedisStoreService };

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

@@ -30,6 +30,7 @@ class RedisStoreService extends index_1.StoreService {
             rpush: 'RPUSH',
             xack: 'XACK',
             xdel: 'XDEL',
+            xlen: 'XLEN',
         };
     }
     getMulti() {
@@ -141,5 +142,20 @@ class RedisStoreService extends index_1.StoreService {
             throw error;
         }
     }
+    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.RedisStoreService = RedisStoreService;

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;
 }
@@ -31,6 +32,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     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>;
     constructor(redisClient: T);
     init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
     isSuccessful(result: any): boolean;
@@ -61,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>;
@@ -105,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
@@ -122,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/stream/clients/ioredis.d.ts

@@ -19,5 +19,6 @@ declare class IORedisStreamService extends StreamService<RedisClientType, RedisM
     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 { IORedisStreamService };