@hotmeshio/hotmesh 0.1.2 → 0.1.4

package/build/services/router/index.js

@@ -22,6 +22,7 @@ class Router {
         this.topic = config.topic;
         this.stream = stream;
         this.store = store;
+        this.throttle = config.throttle;
         this.reclaimDelay = config.reclaimDelay || enums_1.HMSH_XCLAIM_DELAY_MS;
         this.reclaimCount = config.reclaimCount || enums_1.HMSH_XCLAIM_COUNT;
         this.logger = logger;
@@ -38,7 +39,7 @@ class Router {
             await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
         }
         catch (err) {
-            this.logger.debug('consumer-group-exists', { stream, group });
+            this.logger.debug('router-stream-group-exists', { stream, group });
         }
     }
     async publishMessage(topic, streamData, multi) {
@@ -81,25 +82,31 @@ class Router {
         });
     }
     async consumeMessages(stream, group, consumer, callback) {
-        this.logger.info(`stream-consumer-starting`, { group, consumer, stream });
+        this.logger.info(`router-stream-starting`, { group, consumer, stream });
         Router.instances.add(this);
         this.shouldConsume = true;
         await this.createGroup(stream, group);
         let lastCheckedPendingMessagesAt = Date.now();
         async function consume() {
             await this.customSleep();
-            if (!this.shouldConsume) {
-                this.logger.info(`stream-consumer-stopping`, {
-                    group,
-                    consumer,
-                    stream,
-                });
+            if (this.isStopped(group, consumer, stream)) {
+                return;
+            }
+            else if (this.isPaused()) {
+                setImmediate(consume.bind(this));
                 return;
             }
             try {
                 //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.isStopped(group, consumer, stream)) {
+                    return;
+                }
+                else if (this.isPaused()) {
+                    setImmediate(consume.bind(this));
+                    return;
+                }
                 if (this.isStreamMessage(result)) {
                     const [[, messages]] = result;
                     for (const [id, message] of messages) {
@@ -119,7 +126,7 @@ class Router {
             }
             catch (err) {
                 if (this.shouldConsume && process.env.NODE_ENV !== 'test') {
-                    this.logger.error(`stream-consume-message-error`, {
+                    this.logger.error(`router-stream-error`, {
                         err,
                         stream,
                         group,
@@ -136,8 +143,21 @@ class Router {
     isStreamMessage(result) {
         return Array.isArray(result) && Array.isArray(result[0]);
     }
+    isPaused() {
+        return this.throttle === enums_1.MAX_DELAY;
+    }
+    isStopped(group, consumer, stream) {
+        if (!this.shouldConsume) {
+            this.logger.info(`router-stream-stopped`, {
+                group,
+                consumer,
+                stream,
+            });
+        }
+        return !this.shouldConsume;
+    }
     async consumeOne(stream, group, id, message, callback) {
-        this.logger.debug(`stream-consume-one`, { group, stream, id });
+        this.logger.debug(`stream-read-one`, { group, stream, id });
         const [err, input] = this.parseStreamData(message[1]);
         let output;
         let telemetry;
@@ -151,14 +171,14 @@ class Router {
             this.errorCount = 0;
         }
         catch (err) {
-            this.logger.error(`stream-consume-one-error`, { group, stream, id, err });
+            this.logger.error(`stream-read-one-error`, { group, stream, id, err });
             telemetry.setStreamError(err.message);
         }
         const messageId = await this.publishResponse(input, output);
         telemetry.setStreamAttributes({ 'app.worker.mid': messageId });
         await this.ackAndDelete(stream, group, id);
         telemetry.endStreamSpan();
-        this.logger.debug(`stream-consume-one-end`, { group, stream, id });
+        this.logger.debug(`stream-read-one-end`, { group, stream, id });
     }
     async execStreamLeg(input, stream, id, callback) {
         let output;
@@ -293,7 +313,7 @@ class Router {
     }
     async stopConsuming() {
         this.shouldConsume = false;
-        this.logger.info(`stream-consumer-stopping`, this.topic ? { topic: this.topic } : undefined);
+        this.logger.info(`router-stream-stopping`, this.topic ? { topic: this.topic } : undefined);
         this.cancelThrottle();
     }
     cancelThrottle() {
@@ -303,8 +323,10 @@ class Router {
         this.resetThrottleState();
     }
     setThrottle(delayInMillis) {
-        if (!Number.isInteger(delayInMillis) || delayInMillis < 0) {
-            throw new Error('Throttle must be a non-negative integer');
+        if (!Number.isInteger(delayInMillis) ||
+            delayInMillis < 0 ||
+            delayInMillis > enums_1.MAX_DELAY) {
+            throw new Error(`Throttle must be a non-negative integer and not exceed ${enums_1.MAX_DELAY} ms; send -1 to throttle indefinitely`);
         }
         const wasDecreased = delayInMillis < this.throttle;
         this.throttle = delayInMillis;

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 */