redis-smq 7.0.6 → 7.1.0

package/dist/src/lib/queue-manager/queue-manager.d.ts

@@ -2,15 +2,16 @@ import { QueueRateLimit } from './queue-rate-limit';
 import { Namespace } from './namespace';
 import { QueueMetrics } from './queue-metrics';
 import { Queue } from './queue';
+import { RedisClient } from 'redis-smq-common';
 import { ICallback } from 'redis-smq-common/dist/types';
 import { IConfig } from '../../../types';
 export declare class QueueManager {
-    private readonly redisClient;
+    protected readonly redisClient: RedisClient;
     readonly namespace: Namespace;
     readonly queue: Queue;
     readonly queueRateLimit: QueueRateLimit;
     readonly queueMetrics: QueueMetrics;
-    private constructor();
+    protected constructor(namespace: Namespace, queue: Queue, queueRateLimit: QueueRateLimit, queueMetrics: QueueMetrics, redisClient: RedisClient);
     quit(cb: ICallback<void>): void;
     static createInstance(config: IConfig, cb: ICallback<QueueManager>): void;
 }

package/dist/src/lib/queue-manager/queue-manager.js

@@ -8,12 +8,12 @@ const queue_1 = require("./queue");
 const redis_smq_common_1 = require("redis-smq-common");
 const configuration_1 = require("../../config/configuration");
 class QueueManager {
-    constructor(redisClient, namespace, queue, queueRateLimit, queueMetrics) {
-        this.redisClient = redisClient;
+    constructor(namespace, queue, queueRateLimit, queueMetrics, redisClient) {
         this.namespace = namespace;
         this.queue = queue;
         this.queueRateLimit = queueRateLimit;
         this.queueMetrics = queueMetrics;
+        this.redisClient = redisClient;
     }
     quit(cb) {
         this.redisClient.halt(cb);
@@ -33,7 +33,7 @@ class QueueManager {
                 const queue = new queue_1.Queue(cfg, client, nsLogger);
                 const queueRateLimit = new queue_rate_limit_1.QueueRateLimit(cfg, client, nsLogger);
                 const queueMetrics = new queue_metrics_1.QueueMetrics(cfg, client, nsLogger);
-                cb(null, new QueueManager(client, namespace, queue, queueRateLimit, queueMetrics));
+                cb(null, new QueueManager(namespace, queue, queueRateLimit, queueMetrics, client));
             }
         });
     }

package/dist/src/lib/queue-manager/queue-rate-limit.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueRateLimit = void 0;
+const types_1 = require("../../../types");
 const redis_keys_1 = require("../../common/redis-keys/redis-keys");
 const queue_rate_limit_error_1 = require("./errors/queue-rate-limit.error");
 const queue_1 = require("./queue");
@@ -13,9 +14,9 @@ class QueueRateLimit {
     }
     clear(queue, cb) {
         const queueParams = queue_1.Queue.getParams(this.config, queue);
-        const { keyQueueSettings, keyQueueSettingsRateLimit, keyQueueRateLimitCounter, } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        const { keyQueueSettings, keyQueueRateLimitCounter } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
         const multi = this.redisClient.multi();
-        multi.hdel(keyQueueSettings, keyQueueSettingsRateLimit);
+        multi.hdel(keyQueueSettings, types_1.EQueueSettingType.RATE_LIMIT);
         multi.del(keyQueueRateLimitCounter);
         multi.exec((err) => cb(err));
     }
@@ -30,8 +31,8 @@ class QueueRateLimit {
             cb(new queue_rate_limit_error_1.QueueRateLimitError(`Invalid rateLimit.interval. Expected a positive integer >= 1000`));
         }
         const validatedRateLimit = { interval, limit };
-        const { keyQueueSettings, keyQueueSettingsRateLimit } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
-        this.redisClient.hset(keyQueueSettings, keyQueueSettingsRateLimit, JSON.stringify(validatedRateLimit), (err) => cb(err));
+        const { keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        this.redisClient.hset(keyQueueSettings, types_1.EQueueSettingType.RATE_LIMIT, JSON.stringify(validatedRateLimit), (err) => cb(err));
     }
     get(queue, cb) {
         QueueRateLimit.get(this.config, this.redisClient, queue, cb);
@@ -50,8 +51,8 @@ class QueueRateLimit {
     }
     static get(config, redisClient, queue, cb) {
         const queueParams = queue_1.Queue.getParams(config, queue);
-        const { keyQueueSettings, keyQueueSettingsRateLimit } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
-        redisClient.hget(keyQueueSettings, keyQueueSettingsRateLimit, (err, reply) => {
+        const { keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        redisClient.hget(keyQueueSettings, types_1.EQueueSettingType.RATE_LIMIT, (err, reply) => {
             if (err)
                 cb(err);
             else if (!reply)

package/dist/src/lib/queue-manager/queue.d.ts

@@ -6,7 +6,10 @@ export declare class Queue {
     protected redisClient: RedisClient;
     protected logger: ICompatibleLogger;
     constructor(config: IRequiredConfig, redisClient: RedisClient, logger: ICompatibleLogger);
-    create(queue: string | TQueueParams, priorityQueuing: boolean, cb: ICallback<void>): void;
+    create(queue: string | TQueueParams, priorityQueuing: boolean, cb: ICallback<{
+        queue: TQueueParams;
+        settings: TQueueSettings;
+    }>): void;
     getSettings(queue: string | TQueueParams, cb: ICallback<TQueueSettings>): void;
     exists(queue: string | TQueueParams, cb: ICallback<boolean>): void;
     list(cb: ICallback<TQueueParams[]>): void;

package/dist/src/lib/queue-manager/queue.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = void 0;
+const types_1 = require("../../../types");
 const redis_keys_1 = require("../../common/redis-keys/redis-keys");
 const queue_exists_error_1 = require("./errors/queue-exists.error");
 const queue_not_found_error_1 = require("./errors/queue-not-found.error");
 const delete_queue_transaction_1 = require("./delete-queue-transaction");
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_client_1 = require("../../common/redis-client/redis-client");
+const empty_callback_reply_error_1 = require("redis-smq-common/dist/src/errors/empty-callback-reply.error");
 class Queue {
     constructor(config, redisClient, logger) {
         this.config = config;
@@ -15,21 +17,28 @@ class Queue {
     }
     create(queue, priorityQueuing, cb) {
         const queueParams = Queue.getParams(this.config, queue);
-        const { keyQueues, keyNsQueues, keyNamespaces, keyQueueSettings, keyQueueSettingsPriorityQueuing, } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        const { keyQueues, keyNsQueues, keyNamespaces, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
         const queueIndex = JSON.stringify(queueParams);
         this.redisClient.runScript(redis_client_1.ELuaScriptName.CREATE_QUEUE, [
             keyNamespaces,
             keyNsQueues,
             keyQueues,
             keyQueueSettings,
-            keyQueueSettingsPriorityQueuing,
+            types_1.EQueueSettingType.PRIORITY_QUEUING,
         ], [queueParams.ns, queueIndex, JSON.stringify(priorityQueuing)], (err, reply) => {
             if (err)
                 cb(err);
             else if (!reply)
                 cb(new queue_exists_error_1.QueueExistsError());
             else
-                cb();
+                this.getSettings(queueParams, (err, settings) => {
+                    if (err)
+                        cb(err);
+                    else if (!settings)
+                        cb(new empty_callback_reply_error_1.EmptyCallbackReplyError());
+                    else
+                        cb(null, { queue: queueParams, settings });
+                });
         });
     }
     getSettings(queue, cb) {
@@ -65,21 +74,28 @@ class Queue {
     }
     static getSettings(config, redisClient, queue, cb) {
         const queueParams = Queue.getParams(config, queue);
-        const { keyQueueSettings, keyQueueSettingsPriorityQueuing, keyQueueSettingsRateLimit, } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        const { keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
         redisClient.hgetall(keyQueueSettings, (err, reply) => {
             if (err)
                 cb(err);
             else if (!reply || !Object.keys(reply).length)
                 cb(new queue_not_found_error_1.QueueNotFoundError());
             else {
-                const queueSettings = { priorityQueuing: false };
+                const queueSettings = {
+                    priorityQueuing: false,
+                    exchange: null,
+                    rateLimit: null,
+                };
                 for (const key in reply) {
-                    if (key === keyQueueSettingsPriorityQueuing) {
+                    if (key === types_1.EQueueSettingType.PRIORITY_QUEUING) {
                         queueSettings.priorityQueuing = JSON.parse(reply[key]);
                     }
-                    if (key === keyQueueSettingsRateLimit) {
+                    if (key === types_1.EQueueSettingType.RATE_LIMIT) {
                         queueSettings.rateLimit = JSON.parse(reply[key]);
                     }
+                    if (key === types_1.EQueueSettingType.EXCHANGE) {
+                        queueSettings.exchange = reply[key];
+                    }
                 }
                 cb(null, queueSettings);
             }
@@ -87,7 +103,7 @@ class Queue {
     }
     static list(redisClient, cb) {
         const { keyQueues } = redis_keys_1.redisKeys.getMainKeys();
-        redisClient.smembers(keyQueues, (err, reply) => {
+        redisClient.sscanFallback(keyQueues, (err, reply) => {
             if (err)
                 cb(err);
             else if (!reply)

package/dist/src/workers/delay.worker.js

@@ -20,9 +20,9 @@ class DelayWorker extends redis_smq_common_1.Worker {
                         redis_smq_common_1.async.each(messages, (i, _, done) => {
                             multi.lrem(keyDelayedMessages, 1, i);
                             const message = message_1.Message.createFromMessage(i);
-                            message.getRequiredMetadata().incrAttempts();
+                            message.getRequiredMessageState().incrAttempts();
                             const delay = message.getRetryDelay();
-                            message.getRequiredMetadata().setNextRetryDelay(delay);
+                            message.getRequiredMessageState().setNextRetryDelay(delay);
                             (0, schedule_message_1.scheduleMessage)(multi, message);
                             done();
                         }, (err) => {

package/dist/src/workers/requeue.worker.js

@@ -18,10 +18,10 @@ class RequeueWorker extends redis_smq_common_1.Worker {
                         const multi = this.redisClient.multi();
                         redis_smq_common_1.async.each(messages, (messageStr, _, done) => {
                             const message = message_1.Message.createFromMessage(messageStr);
-                            const queue = message.getRequiredQueue();
+                            const queue = message.getDestinationQueue();
                             const { keyQueuePending, keyQueuePendingPriorityMessageWeight } = redis_keys_1.redisKeys.getQueueKeys(queue);
                             multi.lrem(keyRequeueMessages, 1, messageStr);
-                            message.getRequiredMetadata().incrAttempts();
+                            message.getRequiredMessageState().incrAttempts();
                             if (message.hasPriority()) {
                                 const priority = message.getPriority();
                                 if (priority === null)

package/dist/src/workers/schedule.worker.js

@@ -5,6 +5,7 @@ const redis_keys_1 = require("../common/redis-keys/redis-keys");
 const message_1 = require("../lib/message/message");
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_client_1 = require("../common/redis-client/redis-client");
+const types_1 = require("../../types");
 class ScheduleWorker extends redis_smq_common_1.Worker {
     constructor(redisClient, managed) {
         super(managed);
@@ -44,13 +45,13 @@ class ScheduleWorker extends redis_smq_common_1.Worker {
                 redis_smq_common_1.async.each(messages, (msg, _, done) => {
                     var _a;
                     const message = message_1.Message.createFromMessage(msg);
-                    const queue = message.getRequiredQueue();
-                    const { keyQueueSettings, keyQueueSettingsPriorityQueuing, keyQueuePending, keyQueuePendingPriorityMessages, keyQueuePendingPriorityMessageWeight, keyScheduledMessageWeight, keyScheduledMessages, } = redis_keys_1.redisKeys.getQueueKeys(queue);
+                    const queue = message.getDestinationQueue();
+                    const { keyQueueSettings, keyQueuePending, keyQueuePendingPriorityMessages, keyQueuePendingPriorityMessageWeight, keyScheduledMessageWeight, keyScheduledMessages, } = redis_keys_1.redisKeys.getQueueKeys(queue);
                     const nextScheduleTimestamp = message.getNextScheduledTimestamp();
-                    message.getRequiredMetadata().setPublishedAt(Date.now());
+                    message.getRequiredMessageState().setPublishedAt(Date.now());
                     this.redisClient.runScript(redis_client_1.ELuaScriptName.ENQUEUE_SCHEDULED_MESSAGE, [
                         keyQueueSettings,
-                        keyQueueSettingsPriorityQueuing,
+                        types_1.EQueueSettingType.PRIORITY_QUEUING,
                         keyQueuePendingPriorityMessages,
                         keyQueuePendingPriorityMessageWeight,
                         keyQueuePending,

package/dist/types/index.d.ts

@@ -4,6 +4,9 @@ import { Message } from '../src/lib/message/message';
 import { redisKeys } from '../src/common/redis-keys/redis-keys';
 import { ICallback, TLoggerConfig, TRedisConfig } from 'redis-smq-common/dist/types';
 import { EventEmitter } from 'events';
+import { DirectExchange } from '../src/lib/exchange/direct-exchange';
+import { TopicExchange } from '../src/lib/exchange/topic-exchange';
+import { FanOutExchange } from '../src/lib/exchange/fan-out-exchange';
 export declare type TEventListenerInitArgs = {
     eventProvider: EventEmitter;
     config: IRequiredConfig;
@@ -76,6 +79,10 @@ export declare enum EMessageUnacknowledgedCause {
     OFFLINE_CONSUMER = "offline_consumer",
     TTL_EXPIRED = "ttl_expired"
 }
+export declare type TTopicParams = {
+    topic: string;
+    ns: string;
+};
 export declare type TQueueParams = {
     name: string;
     ns: string;
@@ -86,8 +93,14 @@ export declare type TQueueRateLimit = {
 };
 export declare type TQueueSettings = {
     priorityQueuing: boolean;
-    rateLimit?: TQueueRateLimit | null;
+    rateLimit: TQueueRateLimit | null;
+    exchange: string | null;
 };
+export declare enum EQueueSettingType {
+    PRIORITY_QUEUING = "PRIORITY_QUEUING",
+    RATE_LIMIT = "RATE_LIMIT",
+    EXCHANGE = "EXCHANGE"
+}
 export declare type TConsumerInfo = {
     ipAddress: string[];
     hostname: string;
@@ -117,7 +130,8 @@ export declare type TConsumerMessageHandlerParams = {
 };
 export declare type TMessageJSON = {
     createdAt: number;
-    queue: TQueueParams | null;
+    queue: TQueueParams | string | null;
+    exchange: IDirectExchangeParams | ITopicExchangeParams | IFanOutExchangeParams | null;
     ttl: number;
     retryThreshold: number;
     retryDelay: number;
@@ -128,9 +142,24 @@ export declare type TMessageJSON = {
     scheduledDelay: number | null;
     scheduledRepeatPeriod: number | null;
     scheduledRepeat: number;
-    metadata: TMessageMetadataJSON | null;
+    messageState: TMessageState | null;
 };
-export declare type TMessageMetadataJSON = {
+export declare enum EExchangeType {
+    DIRECT = 0,
+    FANOUT = 1,
+    TOPIC = 2
+}
+export declare type TExchange = DirectExchange | TopicExchange | FanOutExchange;
+export interface IExchangeParams<TBindingParams, TBindingType extends EExchangeType> {
+    exchangeTag: string;
+    destinationQueue: TQueueParams | null;
+    bindingParams: TBindingParams;
+    type: TBindingType;
+}
+export declare type IDirectExchangeParams = IExchangeParams<TQueueParams | string, EExchangeType.DIRECT>;
+export declare type IFanOutExchangeParams = IExchangeParams<string, EExchangeType.FANOUT>;
+export declare type ITopicExchangeParams = IExchangeParams<TTopicParams | string, EExchangeType.TOPIC>;
+export declare type TMessageState = {
     uuid: string;
     publishedAt: number | null;
     scheduledAt: number | null;
@@ -147,3 +176,7 @@ export declare type TMessageConsumeOptions = {
     retryDelay: number;
     consumeTimeout: number;
 };
+export declare type TProduceMessageReply = {
+    messages: Message[];
+    scheduled: boolean;
+};

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMessageUnacknowledgedCause = exports.EMessageDeadLetterCause = void 0;
+exports.EExchangeType = exports.EQueueSettingType = exports.EMessageUnacknowledgedCause = exports.EMessageDeadLetterCause = void 0;
 var EMessageDeadLetterCause;
 (function (EMessageDeadLetterCause) {
     EMessageDeadLetterCause["TTL_EXPIRED"] = "ttl_expired";
@@ -15,4 +15,16 @@ var EMessageUnacknowledgedCause;
     EMessageUnacknowledgedCause["OFFLINE_CONSUMER"] = "offline_consumer";
     EMessageUnacknowledgedCause["TTL_EXPIRED"] = "ttl_expired";
 })(EMessageUnacknowledgedCause = exports.EMessageUnacknowledgedCause || (exports.EMessageUnacknowledgedCause = {}));
+var EQueueSettingType;
+(function (EQueueSettingType) {
+    EQueueSettingType["PRIORITY_QUEUING"] = "PRIORITY_QUEUING";
+    EQueueSettingType["RATE_LIMIT"] = "RATE_LIMIT";
+    EQueueSettingType["EXCHANGE"] = "EXCHANGE";
+})(EQueueSettingType = exports.EQueueSettingType || (exports.EQueueSettingType = {}));
+var EExchangeType;
+(function (EExchangeType) {
+    EExchangeType[EExchangeType["DIRECT"] = 0] = "DIRECT";
+    EExchangeType[EExchangeType["FANOUT"] = 1] = "FANOUT";
+    EExchangeType[EExchangeType["TOPIC"] = 2] = "TOPIC";
+})(EExchangeType = exports.EExchangeType || (exports.EExchangeType = {}));
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.0.6",
+  "version": "7.1.0",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "uuid": "8.3.2"
   },
   "peerDependencies": {
-    "redis-smq-common": "^1.0.1"
+    "redis-smq-common": "^1.0.4"
   },
   "devDependencies": {
     "@types/bluebird": "3.5.36",
@@ -59,7 +59,7 @@
     "jest": "27.2.4",
     "lint-staged": "11.1.2",
     "prettier": "2.4.1",
-    "redis-smq-common": "^1.0.1",
+    "redis-smq-common": "^1.0.4",
     "supertest": "6.1.6",
     "ts-jest": "27.0.5",
     "ts-node": "10.2.1",

package/dist/src/lib/producer/errors/message-queue-required.error.d.ts

@@ -1,4 +0,0 @@
-import { errors } from 'redis-smq-common';
-export declare class MessageQueueRequiredError extends errors.RedisSMQError {
-    constructor(msg?: string);
-}

package/dist/src/lib/producer/errors/message-queue-required.error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageQueueRequiredError = void 0;
-const redis_smq_common_1 = require("redis-smq-common");
-class MessageQueueRequiredError extends redis_smq_common_1.errors.RedisSMQError {
-    constructor(msg = 'Can not publish a message without a message queue') {
-        super(msg);
-    }
-}
-exports.MessageQueueRequiredError = MessageQueueRequiredError;
-//# sourceMappingURL=message-queue-required.error.js.map