@hotmeshio/hotmesh 0.1.3 → 0.1.4

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

@@ -29,17 +29,17 @@ class IORedisStoreService extends index_1.StoreService {
                 async exec() {
                     if (commands.length === 0)
                         return [];
-                    const sameKey = commands.every(cmd => {
+                    const sameKey = commands.every((cmd) => {
                         return cmd.args[0] === commands[0].args[0];
                     });
                     if (sameKey) {
                         const multi = my.redisClient.multi();
-                        commands.forEach(cmd => multi[cmd.command](...cmd.args));
+                        commands.forEach((cmd) => multi[cmd.command](...cmd.args));
                         const results = await multi.exec();
-                        return results.map(item => item);
+                        return results.map((item) => item);
                     }
                     else {
-                        return Promise.all(commands.map(cmd => my.redisClient[cmd.command](...cmd.args)));
+                        return Promise.all(commands.map((cmd) => my.redisClient[cmd.command](...cmd.args)));
                     }
                 },
                 xadd(key, id, fields, message) {
@@ -55,10 +55,30 @@ class IORedisStoreService extends index_1.StoreService {
                     return addCommand('xlen', [key]);
                 },
                 xpending(key, group, start, end, count, consumer) {
-                    return addCommand('xpending', [key, group, start, end, count, consumer]);
+                    return addCommand('xpending', [
+                        key,
+                        group,
+                        start,
+                        end,
+                        count,
+                        consumer,
+                    ]);
                 },
                 xclaim(key, group, consumer, minIdleTime, id, ...args) {
-                    return addCommand('xclaim', [key, group, consumer, minIdleTime, id, ...args]);
+                    return addCommand('xclaim', [
+                        key,
+                        group,
+                        consumer,
+                        minIdleTime,
+                        id,
+                        ...args,
+                    ]);
+                },
+                del(key) {
+                    return addCommand('del', [key]);
+                },
+                expire: function (key, seconds) {
+                    return addCommand('expire', [key, seconds]);
                 },
                 hdel(key, itemId) {
                     return addCommand('hdel', [key, itemId]);
@@ -89,7 +109,7 @@ class IORedisStoreService extends index_1.StoreService {
                 },
                 xgroup(command, key, groupName, id, mkStream) {
                     return addCommand('xgroup', [command, key, groupName, id, mkStream]);
-                }
+                },
             };
             return multiInstance;
         }
@@ -131,7 +151,7 @@ class IORedisStoreService extends index_1.StoreService {
                 return ((await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK');
             }
             catch (err) {
-                this.logger.debug(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                this.logger.debug('stream-mkstream-caught', { key, group: groupName });
                 throw err;
             }
         }

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

@@ -58,22 +58,22 @@ class RedisStoreService extends index_1.StoreService {
                 async exec() {
                     if (commands.length === 0)
                         return [];
-                    const sameKey = commands.every(cmd => {
+                    const sameKey = commands.every((cmd) => {
                         return cmd.args[0] === commands[0].args[0];
                     });
                     if (sameKey) {
                         const multi = my.redisClient.multi();
-                        commands.forEach(cmd => {
+                        commands.forEach((cmd) => {
                             if (cmd.command === 'ZADD') {
                                 return multi.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
                             }
                             return multi[cmd.command](...cmd.args);
                         });
                         const results = await multi.exec();
-                        return results.map(item => item);
+                        return results.map((item) => item);
                     }
                     else {
-                        return Promise.all(commands.map(cmd => {
+                        return Promise.all(commands.map((cmd) => {
                             if (cmd.command === 'ZADD') {
                                 return my.redisClient.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
                             }
@@ -94,10 +94,30 @@ class RedisStoreService extends index_1.StoreService {
                     return addCommand('XLEN', [key]);
                 },
                 XCLAIM(key, group, consumer, minIdleTime, id, ...args) {
-                    return addCommand('XCLAIM', [key, group, consumer, minIdleTime, id, ...args]);
+                    return addCommand('XCLAIM', [
+                        key,
+                        group,
+                        consumer,
+                        minIdleTime,
+                        id,
+                        ...args,
+                    ]);
                 },
                 XPENDING(key, group, start, end, count, consumer) {
-                    return addCommand('XPENDING', [key, group, start, end, count, consumer]);
+                    return addCommand('XPENDING', [
+                        key,
+                        group,
+                        start,
+                        end,
+                        count,
+                        consumer,
+                    ]);
+                },
+                DEL: function (key) {
+                    return addCommand('DEL', [key]);
+                },
+                EXPIRE: function (key, seconds) {
+                    return addCommand('EXPIRE', [key, seconds]);
                 },
                 HDEL(key, itemId) {
                     return addCommand('HDEL', [key, itemId]);
@@ -129,9 +149,6 @@ class RedisStoreService extends index_1.StoreService {
                 XGROUP(command, key, groupName, id, mkStream) {
                     return addCommand('XGROUP', [command, key, groupName, id, mkStream]);
                 },
-                DEL: function (key) {
-                    throw new Error('Function not implemented.');
-                },
                 EXISTS: function (key) {
                     throw new Error('Function not implemented.');
                 },
@@ -152,7 +169,7 @@ class RedisStoreService extends index_1.StoreService {
                 },
                 ZSCORE: function (key, value) {
                     throw new Error('Function not implemented.');
-                }
+                },
             };
             return multiInstance;
         }

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

@@ -11,6 +11,7 @@ import { Transitions } from '../../types/transition';
 import { ReclaimedMessageType } from '../../types/stream';
 import { JobCompletionOptions, JobInterruptOptions } from '../../types/job';
 import { WorkListTaskType } from '../../types/task';
+import { ThrottleOptions } from '../../types/quorum';
 import { Cache } from './cache';
 interface AbstractRedisClient {
     exec(): any;
@@ -101,7 +102,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * purposeful re-entry.
      */
     collateSynthetic(jobId: string, guid: string, amount: number, multi?: U): Promise<number>;
-    setStateNX(jobId: string, appId: string): Promise<boolean>;
+    setStateNX(jobId: string, appId: string, status?: number): Promise<boolean>;
     getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
     getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;
     setSchemas(schemas: Record<string, ActivityType>, appVersion: AppVID): Promise<any>;
@@ -119,7 +120,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     getActiveTaskQueue(): Promise<string | null>;
     deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string, scrub?: boolean): Promise<void>;
     processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
-    expireJob(jobId: string, inSeconds: number): Promise<void>;
+    expireJob(jobId: string, inSeconds: number, redisMulti?: U): Promise<void>;
     /**
      * register the descendants of an expired origin flow to be
      * expired at a future date; options indicate whether this
@@ -162,5 +163,8 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     scrub(jobId: string): Promise<void>;
     findJobs(queryString?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, string[]]>;
     findJobFields(jobId: string, fieldMatchPattern?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, StringStringType]>;
+    setThrottleRate(options: ThrottleOptions): Promise<void>;
+    getThrottleRates(): Promise<StringStringType>;
+    getThrottleRate(topic: string): Promise<number>;
 }
 export { StoreService };

package/build/services/store/index.js

@@ -24,11 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoreService = void 0;
+const errors_1 = require("../../modules/errors");
 const key_1 = require("../../modules/key");
 const serializer_1 = require("../serializer");
 const utils_1 = require("../../modules/utils");
 const enums_1 = require("../../modules/enums");
-const errors_1 = require("../../modules/errors");
 const cache_1 = require("./cache");
 class StoreService {
     constructor(redisClient) {
@@ -593,9 +593,9 @@ class StoreService {
         });
         return await (multi || this.redisClient)[this.commands.hincrbyfloat](jobKey, guid, amount);
     }
-    async setStateNX(jobId, appId) {
+    async setStateNX(jobId, appId, status) {
         const hashKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
-        const result = await this.redisClient[this.commands.hsetnx](hashKey, ':', '1');
+        const result = await this.redisClient[this.commands.hsetnx](hashKey, ':', status?.toString() ?? '1');
         return this.isSuccessful(result);
     }
     async getSchema(activityId, appVersion) {
@@ -803,13 +803,13 @@ class StoreService {
     async processTaskQueue(sourceKey, destinationKey) {
         return await this.redisClient[this.commands.lmove](sourceKey, destinationKey, 'LEFT', 'RIGHT');
     }
-    async expireJob(jobId, inSeconds) {
+    async expireJob(jobId, inSeconds, redisMulti) {
         if (!isNaN(inSeconds) && inSeconds > 0) {
             const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, {
                 appId: this.appId,
                 jobId,
             });
-            await this.redisClient[this.commands.expire](jobKey, inSeconds);
+            await (redisMulti || this.redisClient)[this.commands.expire](jobKey, inSeconds);
         }
     }
     /**
@@ -1004,5 +1004,37 @@ class StoreService {
         } while (cursor !== '0' && len < limit);
         return [cursor, matchingFields];
     }
+    async setThrottleRate(options) {
+        const key = this.mintKey(key_1.KeyType.THROTTLE_RATE, { appId: this.appId });
+        //engine guids are session specific. no need to persist
+        if (options.guid) {
+            return;
+        }
+        //if a topic, update
+        if (options.topic) {
+            await this.redisClient[this.commands.hset](key, options.topic, options.throttle.toString());
+        }
+        else {
+            //if no topic, update all
+            const multi = this.getMulti();
+            multi[this.commands.del](key);
+            multi[this.commands.hset](key, ':', options.throttle.toString());
+            await multi.exec();
+        }
+    }
+    async getThrottleRates() {
+        const key = this.mintKey(key_1.KeyType.THROTTLE_RATE, { appId: this.appId });
+        const response = await this.redisClient[this.commands.hgetall](key);
+        return response ?? {};
+    }
+    async getThrottleRate(topic) {
+        const response = await this.getThrottleRates();
+        const rate = topic in response ? Number(response[topic]) : 0;
+        if (isNaN(rate))
+            return 0;
+        if (rate == -1)
+            return enums_1.MAX_DELAY;
+        return Math.max(Math.min(rate, enums_1.MAX_DELAY), 0);
+    }
 }
 exports.StoreService = StoreService;

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

@@ -26,7 +26,7 @@ class IORedisStreamService extends index_1.StreamService {
                 return ((await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK');
             }
             catch (error) {
-                this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                this.logger.debug('stream-mkstream-caught', { key, group: groupName });
                 throw error;
             }
         }

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

@@ -32,10 +32,10 @@ class RedisStreamService extends index_1.StreamService {
                 ...args,
             ])) === 1);
         }
-        catch (err) {
+        catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.error(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, err);
-            throw err;
+            this.logger.error(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { ...error });
+            throw error;
         }
     }
     async xadd(key, id, ...args) {
@@ -48,9 +48,9 @@ class RedisStreamService extends index_1.StreamService {
                 [args[0]]: args[1],
             });
         }
-        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) {
@@ -67,9 +67,9 @@ class RedisStreamService extends index_1.StreamService {
                 id,
             ]);
         }
-        catch (err) {
-            this.logger.error(`Error in reading data from group: ${groupName} in stream: ${streamName}`, 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) {
@@ -86,13 +86,13 @@ class RedisStreamService extends index_1.StreamService {
             try {
                 return await this.redisClient.sendCommand(['XPENDING', ...args]);
             }
-            catch (err) {
-                this.logger.error('err, args', err, args);
+            catch (error) {
+                this.logger.error('error, args', { ...error }, args);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error retrieving pending messages for group: ${group} in key: ${key}`, { ...error });
+            throw error;
         }
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
@@ -107,9 +107,9 @@ class RedisStreamService extends index_1.StreamService {
                 ...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 claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });
+            throw error;
         }
     }
     async xack(key, group, id, multi) {
@@ -122,9 +122,9 @@ class RedisStreamService extends index_1.StreamService {
                 return await 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 acknowledging messages in group: ${group} for key: ${key}`, { ...error });
+            throw error;
         }
     }
     async xdel(key, id, multi) {
@@ -137,9 +137,9 @@ class RedisStreamService extends index_1.StreamService {
                 return await this.redisClient.XDEL(key, id);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error deleting messages with ids: ${id} for key: ${key}`, { ...error });
+            throw error;
         }
     }
     async xlen(key, multi) {

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

@@ -28,7 +28,7 @@ declare class WorkerService {
     initStoreChannel(service: WorkerService, store: RedisClient): Promise<void>;
     initSubChannel(service: WorkerService, sub: RedisClient): Promise<void>;
     initStreamChannel(service: WorkerService, stream: RedisClient): Promise<void>;
-    initRouter(worker: HotMeshWorker, logger: ILogger): Router;
+    initRouter(worker: HotMeshWorker, logger: ILogger): Promise<Router>;
     subscriptionHandler(): SubscriptionCallback;
     /**
      * A quorum-wide command to broadcaset system details.

package/build/services/worker/index.js

@@ -37,7 +37,7 @@ class WorkerService {
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.topic);
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.guid);
                 await service.initStreamChannel(service, worker.stream);
-                service.router = service.initRouter(worker, logger);
+                service.router = await service.initRouter(worker, logger);
                 const key = service.stream.mintKey(key_1.KeyType.STREAMS, {
                     appId: service.appId,
                     topic: worker.topic,
@@ -84,7 +84,8 @@ class WorkerService {
         }
         await service.stream.init(service.namespace, service.appId, service.logger);
     }
-    initRouter(worker, logger) {
+    async initRouter(worker, logger) {
+        const throttle = await this.store.getThrottleRate(worker.topic);
         return new router_1.Router({
             namespace: this.namespace,
             appId: this.appId,
@@ -93,6 +94,7 @@ class WorkerService {
             topic: worker.topic,
             reclaimDelay: worker.reclaimDelay,
             reclaimCount: worker.reclaimCount,
+            throttle,
         }, this.stream, this.store, logger);
     }
     subscriptionHandler() {

package/build/types/durable.d.ts

@@ -260,6 +260,17 @@ type WorkflowOptions = {
      * default is true; if false, will not await the execution
      */
     await?: boolean;
+    /**
+     * If provided, the job will initialize in an expired state, reserving
+     * only the job ID (HSETNX) and persisting search and marker (if provided).
+     * If a `resume` signal is sent before the specified number of seconds,
+     * the job will resume as normal, transition to the adjacent children
+     * of the trigger. If the job is not resumed within the number
+     * of seconds specified, the job will be scrubbed. No dependencies
+     * are added for a job in an expired state; however, dependencies
+     * will be added after the job is resumed if relevant.
+     */
+    expired?: number;
 };
 /**
  * Options for setting up a hook.

package/build/types/hotmesh.d.ts

@@ -9,7 +9,7 @@ import { LogLevel } from './logger';
  */
 declare enum KeyType {
     APP = "APP",
-    ENGINE_ID = "ENGINE",
+    THROTTLE_RATE = "THROTTLE_RATE",
     HOOKS = "HOOKS",
     JOB_DEPENDENTS = "JOB_DEPENDENTS",
     JOB_STATE = "JOB_STATE",

package/build/types/hotmesh.js

@@ -7,7 +7,7 @@ exports.KeyType = void 0;
 var KeyType;
 (function (KeyType) {
     KeyType["APP"] = "APP";
-    KeyType["ENGINE_ID"] = "ENGINE";
+    KeyType["THROTTLE_RATE"] = "THROTTLE_RATE";
     KeyType["HOOKS"] = "HOOKS";
     KeyType["JOB_DEPENDENTS"] = "JOB_DEPENDENTS";
     KeyType["JOB_STATE"] = "JOB_STATE";

package/build/types/job.d.ts

@@ -77,6 +77,17 @@ type ExtensionType = {
      * the initial data set.
      */
     marker?: StringStringType;
+    /**
+     * If provided, the job will initialize in an expired state, reserving
+     * only the job ID (HSETNX) and persisting search and marker (if provided).
+     * If a `resume` signal is sent before the specified number of seconds,
+     * the job will resume as normal, transition the the adjacent children
+     * of the trigger. If the job is not resumed within the
+     * number of seconds specified, the job will be scrubbed. No dependencies
+     * are added for a job in an expired state; however, dependencies will be
+     * added after the job is resumed if relevant.
+     */
+    expired?: number;
 };
 /**
  * job_status semaphore

package/build/types/quorum.d.ts

@@ -30,11 +30,9 @@ export type ThrottleOptions = {
     topic?: string;
     /** entity/noun */
     entity?: string;
-    /** in milliseconds; default is 0 */
+    /** in milliseconds; set to -1 for indefinite throttle */
     throttle: number;
-    /** namespace
-     * @default 'durable'
-     */
+    /** namespace */
     namespace?: string;
 };
 export interface QuorumProfile {

package/build/types/redis.d.ts

@@ -68,6 +68,7 @@ interface RedisRedisMultiType {
     XLEN(key: string): this;
     DEL(key: string): this;
     EXISTS(key: string): this;
+    EXPIRE(key: string, seconds: number): this;
     HDEL(key: string, itemId: string): this;
     HGET(key: string, itemId: string): this;
     HGETALL(key: string): this;
@@ -215,6 +216,8 @@ interface IORedisMultiType {
     xlen(key: string): this;
     xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
+    del(key: string): this;
+    expire(key: string, seconds: number): this;
     hdel(key: string, itemId: string): this;
     hget(key: string, itemId: string): this;
     hgetall(key: string): this;

package/build/types/stream.d.ts

@@ -122,6 +122,8 @@ export type StreamConfig = {
     guid: string;
     /** Role associated with the stream */
     role: StreamRole;
+    /** Default throttle (read from KeyType.THROTTLE_RATE) */
+    throttle: number;
     /** Optional topic for the stream */
     topic?: string;
     /** Delay before a message can be reclaimed, defaults to 60,000 milliseconds */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -31,7 +31,7 @@
     "test:durable:collision": "NODE_ENV=test jest ./tests/durable/collision/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:hello": "HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:interrupt": "NODE_ENV=test jest ./tests/durable/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
@@ -41,6 +41,7 @@
     "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:expired": "NODE_ENV=test jest ./tests/functional/expired/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
     "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",

package/types/durable.ts

@@ -200,7 +200,8 @@ export type WorkflowSearchSchema = Record<
      * literal value to use for the indexed field name (without including the standard underscore (_) prefix isolate)
      */
     fieldName?: string;
-  }>;
+  }
+>;
 
 type WorkflowSearchOptions = {
   /** FT index name (myapp:myindex) */
@@ -312,6 +313,18 @@ type WorkflowOptions = {
    * default is true; if false, will not await the execution
    */
   await?: boolean;
+
+  /**
+   * If provided, the job will initialize in an expired state, reserving
+   * only the job ID (HSETNX) and persisting search and marker (if provided).
+   * If a `resume` signal is sent before the specified number of seconds,
+   * the job will resume as normal, transition to the adjacent children
+   * of the trigger. If the job is not resumed within the number
+   * of seconds specified, the job will be scrubbed. No dependencies
+   * are added for a job in an expired state; however, dependencies
+   * will be added after the job is resumed if relevant.
+   */
+  expired?: number;
 };
 
 /**

package/types/hotmesh.ts

@@ -11,7 +11,7 @@ import { LogLevel } from './logger';
  */
 enum KeyType {
   APP = 'APP',
-  ENGINE_ID = 'ENGINE',
+  THROTTLE_RATE = 'THROTTLE_RATE',
   HOOKS = 'HOOKS',
   JOB_DEPENDENTS = 'JOB_DEPENDENTS',
   JOB_STATE = 'JOB_STATE',

package/types/job.ts

@@ -106,6 +106,18 @@ type ExtensionType = {
    * the initial data set.
    */
   marker?: StringStringType;
+
+  /**
+   * If provided, the job will initialize in an expired state, reserving
+   * only the job ID (HSETNX) and persisting search and marker (if provided).
+   * If a `resume` signal is sent before the specified number of seconds,
+   * the job will resume as normal, transition the the adjacent children
+   * of the trigger. If the job is not resumed within the
+   * number of seconds specified, the job will be scrubbed. No dependencies
+   * are added for a job in an expired state; however, dependencies will be
+   * added after the job is resumed if relevant.
+   */
+  expired?: number;
 };
 
 /**

package/types/quorum.ts

@@ -34,11 +34,9 @@ export type ThrottleOptions = {
   topic?: string;
   /** entity/noun */
   entity?: string;
-  /** in milliseconds; default is 0 */
+  /** in milliseconds; set to -1 for indefinite throttle */
   throttle: number;
-  /** namespace
-   * @default 'durable'
-   */
+  /** namespace */
   namespace?: string;
 };
 

package/types/redis.ts

@@ -74,6 +74,7 @@ interface RedisRedisMultiType {
   XLEN(key: string): this;
   DEL(key: string): this;
   EXISTS(key: string): this;
+  EXPIRE(key: string, seconds: number): this;
   HDEL(key: string, itemId: string): this;
   HGET(key: string, itemId: string): this;
   HGETALL(key: string): this;
@@ -303,6 +304,8 @@ interface IORedisMultiType {
     id: string,
     ...args: string[]
   ): this;
+  del(key: string): this;
+  expire(key: string, seconds: number): this;
   hdel(key: string, itemId: string): this;
   hget(key: string, itemId: string): this;
   hgetall(key: string): this;

package/types/stream.ts

@@ -130,6 +130,8 @@ export type StreamConfig = {
   guid: string;
   /** Role associated with the stream */
   role: StreamRole;
+  /** Default throttle (read from KeyType.THROTTLE_RATE) */
+  throttle: number;
   /** Optional topic for the stream */
   topic?: string;
   /** Delay before a message can be reclaimed, defaults to 60,000 milliseconds */