redis-smq 7.0.0-rc.3 → 7.0.0-rc.6

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## 7.0.0-rc.6 (2022-05-31)
+
+* Bump up redis-smq-common to v1.0.0-rc.11 (43717f0)
+
+## 7.0.0-rc.5 (2022-05-31)
+
+* Bump up redis-smq-common to v1.0.0-rc.10 (e025525)
+* Update docs (738d9d0)
+
+## 7.0.0-rc.4 (2022-05-30)
+
+* Update README.md (fef27c1)
+* Support node-redis v4 (c7a91b1)
+* Drop support for node.js v12 (0b5a4e9)
+* Fix outdated documentation (d3bf31b)
+* Fix broken link (fd48c86)
+
 ## 7.0.0-rc.3 (2022-05-26)
 
 * Update migration/configuration/message/message-manager references (6d53877)

package/README.md

@@ -15,23 +15,23 @@
 
 RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing them asynchronously with consumers. Backed by Redis, it allows scaling up your application with ease of use.
 
-> ☝ The master branch reflects the latest changes and updates. It is currently going under heavy development. To view the documentation of the latest stable release see [v6.4.2 docs](https://github.com/weyoss/redis-smq/tree/v6.4.2).
+> ☝ The master branch reflects the latest changes and updates. It is currently going under heavy development. To view the release documentation see [v6.4.2 docs](https://github.com/weyoss/redis-smq/tree/v6.4.2).
 
 ## Features
 
-* **[High-performance message processing](docs/performance.md)**
+* **[High-performance message processing](/docs/performance.md)**
 * **[Multi-Queue Producers](#producer-class) & [Multi-Queue Consumers](#consumer-class)**: Offering very flexible models which make RedisSMQ an ideal message broker for your microservices. 
 * **[Supporting both at-least-once/at-most-once delivery](/docs/api/message.md#messageprototypesetretrythreshold)**: In case of failures, while delivering or processing a message, RedisSMQ can guaranty that the message will be not lost and redelivered again. When configured to do so, RedisSMQ can also ensure that the message is delivered at-most-once.
-* **[Message Expiration](docs/api/message.md#messageprototypesetttl)**: A message will not be delivered if it has been in a queue for longer than a given amount of time, called TTL (time-to-live).
-* **[Message Consumption Timeout](docs/api/message.md#messageprototypesetconsumetimeout)**: Timeout for consuming messages.
-* **[Queue Rate Limiting](docs/queue-rate-limiting.md)**: Allowing you to control the rate at which the messages are consumed from a given queue.
-* **[Scheduling Messages](docs/scheduling-messages.md)**: Messages can be configured to be delayed, delivered for N times with an optional period between deliveries, and to be scheduled using CRON expressions.
-* **[Reliable Priority Queues](docs/priority-queues.md)**: Supports priority messaging.
-* **[Multiplexing](docs/multiplexing.md)**: A feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
+* **[Message Expiration](/docs/api/message.md#messageprototypesetttl)**: A message will not be delivered if it has been in a queue for longer than a given amount of time, called TTL (time-to-live).
+* **[Message Consumption Timeout](/docs/api/message.md#messageprototypesetconsumetimeout)**: Timeout for consuming messages.
+* **[Queue Rate Limiting](/docs/queue-rate-limiting.md)**: Allowing you to control the rate at which the messages are consumed from a given queue.
+* **[Scheduling Messages](/docs/scheduling-messages.md)**: Messages can be configured to be delayed, delivered for N times with an optional period between deliveries, and to be scheduled using CRON expressions.
+* **[Reliable Priority Queues](/docs/priority-queues.md)**: Supports priority messaging.
+* **[Multiplexing](/docs/multiplexing.md)**: A feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
 * **[HTTP API](https://github.com/weyoss/redis-smq-monitor)**: an HTTP interface is provided to interact with the MQ.
 * **[Web UI](https://github.com/weyoss/redis-smq-monitor-client)**: RedisSMQ can be managed also from your web browser.
-* **[Logging](docs/logs.md)**: Comes with a built-in JSON logger. But you can also use your own logger instance.
-* **[Configurable](docs/configuration.md)**: Many options and features can be configured.
+* **[Logging](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)**: Comes with a built-in JSON logger. But you can also use your own logger instance.
+* **[Configurable](/docs/configuration.md)**: Many options and features can be configured.
 * **Both redis & ioredis clients are supported**: RedisSMQ can be configured to use either `redis` or `ioredis` to connect to Redis server.
 * **Rigorously tested**: With 100+ tests and code coverage no less than 80%.
 * **Highly optimized**: Strongly-typed and implemented using pure callbacks, with small memory footprint and no memory leaks. See [callbacks vs promises vs async/await benchmarks](http://bluebirdjs.com/docs/benchmarks.html).
@@ -41,7 +41,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 
  
 
-![RedisSMQ Overview](docs/redis-smq-overview.png)
+![RedisSMQ Overview](/docs/redis-smq-overview.png)
 
 ## Table of Content
 
@@ -54,16 +54,16 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
        2. [Producer Class](#producer-class)
        3. [Consumer Class](#consumer-class)
    2. Advanced Topics
-      1. [Scheduling Messages](docs/scheduling-messages.md)
-      2. [Priority Queues](docs/priority-queues.md)
-      3. [Queue Rate Limiting](docs/queue-rate-limiting.md)
-      4. [Multiplexing](docs/multiplexing.md)
-      5. [Message Manager](docs/api/message-manager.md)
-      6. [Queue Manager](docs/api/queue-manager.md)
+      1. [Scheduling Messages](/docs/scheduling-messages.md)
+      2. [Priority Queues](/docs/priority-queues.md)
+      3. [Queue Rate Limiting](/docs/queue-rate-limiting.md)
+      4. [Multiplexing](/docs/multiplexing.md)
+      5. [Message Manager](/docs/api/message-manager.md)
+      6. [Queue Manager](/docs/api/queue-manager.md)
       7. [HTTP API](https://github.com/weyoss/redis-smq-monitor)
       8. [Web UI](https://github.com/weyoss/redis-smq-monitor-client)
-      9. [Logs](docs/logs.md)
-5. [RedisSMQ Architecture](docs/redis-smq-architecture.md)
+      9. [Logs](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)
+5. [RedisSMQ Architecture](/docs/redis-smq-architecture.md)
 6. [Performance](#performance)
 7. [Contributing](#contributing)
 8. [License](#license)
@@ -83,12 +83,12 @@ npm install redis-smq --save
 
 Considerations:
 
-- RedisSMQ is targeted to be used in production environments. Therefore, only active LTS and maintenance LTS Node.js releases (v12, v14, and v16) are supported. The latest stable Node.js version is recommended.
-- Minimal Redis server version is 2.6.12. The latest stable Redis version is recommended.
+- Minimal Node.js version is >= 14 (RedisSMQ is tested under current active LTS and maintenance LTS Node.js releases).
+- Minimal Redis server version is 2.6.12 (RedisSMQ is tested under Redis v2.6, v3, v4, v5, and v6).
 
 ## Configuration
 
-See [Configuration](docs/configuration.md) for more details.
+See [Configuration](/docs/configuration.md) for more details.
 
 ## Usage
 
@@ -98,8 +98,9 @@ You can create a queue, view existing queues, or delete a queue using the [Queue
 
 ```javascript
 const { QueueManager } = require('redis-smq');
+const config = require('./config')
 
-QueueManager.createInstance((err, queueManager) => {
+QueueManager.createInstance(config, (err, queueManager) => {
   if (err) console.log(err);
   else queueManager.queue.create('test_queue', false, (err) => console.log(err));
 })
@@ -128,7 +129,7 @@ message
 
 The `Message` class provides many methods for setting up different message parameters such as message body, message priority, message TTL, etc. 
 
-See [Message Reference](docs/api/message.md) for more details.
+See [Message Reference](/docs/api/message.md) for more details.
 
 #### Producer Class
 
@@ -161,7 +162,7 @@ producer.produce(message, (err) => {
 });
 ```
 
-See [Producer Reference](docs/api/producer.md) for more details.
+See [Producer Reference](/docs/api/producer.md) for more details.
 
 #### Consumer Class
 
@@ -213,35 +214,35 @@ A `dead-letter queue` is a system generated queue that holds all messages that c
 
 By default, RedisSMQ does not store acknowledged and dead-lettered messages for saving disk and memory space, and also to increase message processing performance. If you need such feature, you can enable it from your [configuration](/docs/configuration.md) object.
 
-See [Consumer Reference](docs/api/consumer.md) for more details.
+See [Consumer Reference](/docs/api/consumer.md) for more details.
 
 ### Advanced Topics
 
-* [Scheduling Messages](docs/scheduling-messages.md)
+* [Scheduling Messages](/docs/scheduling-messages.md)
 
-* [Priority Queues](docs/priority-queues.md)
+* [Priority Queues](/docs/priority-queues.md)
 
-* [Queue Rate Limiting](docs/queue-rate-limiting.md)
+* [Queue Rate Limiting](/docs/queue-rate-limiting.md)
 
-* [Multiplexing](docs/multiplexing.md)
+* [Multiplexing](/docs/multiplexing.md)
   
-* [Message Manager](docs/api/message-manager.md)
+* [Message Manager](/docs/api/message-manager.md)
 
-* [Queue Manager](docs/api/queue-manager.md)
+* [Queue Manager](/docs/api/queue-manager.md)
 
 * [HTTP API](https://github.com/weyoss/redis-smq-monitor)
 
 * [Web UI](https://github.com/weyoss/redis-smq-monitor-client)
 
-* [Logs](docs/logs.md)
+* [Logs](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)
 
 ## RedisSMQ Architecture
 
-* See [Architecture Overview](docs/redis-smq-architecture.md).
+* See [Architecture Overview](/docs/redis-smq-architecture.md).
 
 ## Performance
 
-See [Performance](docs/performance.md) for more details.
+See [Performance](/docs/performance.md) for more details.
 
 ## Contributing
 

package/dist/src/lib/base.js

@@ -12,7 +12,7 @@ class Base extends events_1.EventEmitter {
         super();
         this.sharedRedisClient = null;
         this.setUpSharedRedisClient = (cb) => {
-            redis_smq_common_1.RedisClient.getNewInstance(this.config.redis, (err, client) => {
+            (0, redis_smq_common_1.createClientInstance)(this.config.redis, (err, client) => {
                 if (err)
                     cb(err);
                 else if (!client)

package/dist/src/lib/broker/dead-letter-message.d.ts

@@ -1,6 +1,6 @@
 import { EMessageDeadLetterCause, EMessageUnacknowledgedCause, IRequiredConfig } from '../../../types';
 import { Message } from '../message/message';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function deadLetterMessage(config: IRequiredConfig, mixed: TRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, deadLetterCause: EMessageDeadLetterCause): void;
+export declare function deadLetterMessage(config: IRequiredConfig, mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, deadLetterCause: EMessageDeadLetterCause): void;
 export declare function deadLetterMessage(config: IRequiredConfig, mixed: RedisClient, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, deadLetterCause: EMessageDeadLetterCause, cb: ICallback<void>): void;

package/dist/src/lib/broker/delay-message.d.ts

@@ -1,7 +1,7 @@
 import { EMessageUnacknowledgedCause } from '../../../types';
 import { Message } from '../message/message';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function delayMessageTransaction(mixed: TRedisClientMulti, message: Message, keyQueueProcessing: string): void;
-export declare function delayMessage(mixed: TRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause): void;
+export declare function delayMessageTransaction(mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string): void;
+export declare function delayMessage(mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause): void;
 export declare function delayMessage(mixed: RedisClient, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, cb: ICallback<void>): void;

package/dist/src/lib/broker/requeue-message.d.ts

@@ -1,6 +1,6 @@
 import { EMessageUnacknowledgedCause } from '../../../types';
 import { Message } from '../message/message';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function requeueMessage(mixed: TRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause): void;
+export declare function requeueMessage(mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause): void;
 export declare function requeueMessage(mixed: RedisClient, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, cb: ICallback<void>): void;

package/dist/src/lib/broker/retry-message.d.ts

@@ -1,6 +1,6 @@
 import { EMessageDeadLetterCause, EMessageUnacknowledgedCause, IRequiredConfig } from '../../../types';
 import { Message } from '../message/message';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function retryMessage(config: IRequiredConfig, mixed: TRedisClientMulti, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause): EMessageDeadLetterCause | void;
+export declare function retryMessage(config: IRequiredConfig, mixed: IRedisClientMulti, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause): EMessageDeadLetterCause | void;
 export declare function retryMessage(config: IRequiredConfig, mixed: RedisClient, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause, cb: ICallback<EMessageDeadLetterCause | void>): void;

package/dist/src/lib/broker/schedule-message.d.ts

@@ -1,5 +1,5 @@
 import { Message } from '../message/message';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function scheduleMessage(mixed: TRedisClientMulti, message: Message): boolean;
+export declare function scheduleMessage(mixed: IRedisClientMulti, message: Message): boolean;
 export declare function scheduleMessage(mixed: RedisClient, message: Message, cb: ICallback<void>): void;

package/dist/src/lib/consumer/consumer-heartbeat.js

@@ -62,7 +62,7 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
         const multi = this.redisClient.multi();
         multi.hset(this.keyHeartbeats, this.consumer.getId(), heartbeatPayloadStr);
         multi.zadd(this.keyHeartbeatTimestamps, timestamp, this.consumer.getId());
-        this.redisClient.execMulti(multi, (err) => {
+        multi.exec((err) => {
             if (err)
                 this.emit(events_1.events.ERROR, err);
             else {
@@ -171,7 +171,7 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
                 multi.hdel(keyHeartbeats, consumerId);
                 multi.zrem(keyHeartbeatConsumerWeight, consumerId);
                 (0, offline_consumers_1.handleOfflineConsumer)(config, multi, redisClient, consumerId, done);
-            }, () => redisClient.execMulti(multi, (err) => cb(err)));
+            }, () => multi.exec((err) => cb(err)));
         }
         else
             cb();

package/dist/src/lib/consumer/consumer-message-handler/dequeue-message.d.ts

@@ -14,8 +14,8 @@ export declare class DequeueMessage {
     protected priorityQueuing: boolean;
     constructor(messageHandler: MessageHandler, redisClient: RedisClient);
     protected dequeueMessageWithPriority(cb: ICallback<string>): void;
-    protected waitForMessage(cb: ICallback<string>): void;
-    protected dequeueMessage(cb: ICallback<string>): void;
+    protected waitForMessage(cb: ICallback<string | null>): void;
+    protected dequeueMessage(cb: ICallback<string | null>): void;
     dequeue(): void;
     run(cb: ICallback<void>): void;
     quit(cb: ICallback<void>): void;

package/dist/src/lib/consumer/consumer-message-handler/message-handler-runner.js

@@ -41,7 +41,7 @@ class MessageHandlerRunner {
     }
     runMessageHandler(handlerParams, cb) {
         const { redis } = this.config;
-        redis_smq_common_1.RedisClient.getNewInstance(redis, (err, client) => {
+        (0, redis_smq_common_1.createClientInstance)(redis, (err, client) => {
             if (err)
                 cb(err);
             else if (!client)

package/dist/src/lib/consumer/consumer-message-handler/message-handler.d.ts

@@ -5,7 +5,7 @@ import { DequeueMessage } from './dequeue-message';
 import { ConsumeMessage } from './consume-message';
 import { Consumer } from '../consumer';
 import { PowerManager, RedisClient } from 'redis-smq-common';
-import { ICallback, ICompatibleLogger, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, ICompatibleLogger, IRedisClientMulti } from 'redis-smq-common/dist/types';
 export declare class MessageHandler extends EventEmitter {
     protected id: string;
     protected consumer: Consumer;
@@ -32,5 +32,5 @@ export declare class MessageHandler extends EventEmitter {
     getConfig(): IRequiredConfig;
     isRunning(): boolean;
     getHandler(): TConsumerMessageHandler;
-    static cleanUp(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: TRedisClientMulti | undefined, cb: ICallback<void>): void;
+    static cleanUp(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: IRedisClientMulti | undefined, cb: ICallback<void>): void;
 }

package/dist/src/lib/consumer/consumer-message-handler/message-handler.js

@@ -155,7 +155,7 @@ class MessageHandler extends events_2.EventEmitter {
             else if (pendingMulti)
                 cb();
             else
-                redisClient.execMulti(multi, (err) => cb(err));
+                multi.exec((err) => cb(err));
         });
     }
 }

package/dist/src/lib/consumer/consumer-message-handler/multiplexed-message-handler/multiplexed-message-handler-runner.js

@@ -82,7 +82,7 @@ class MultiplexedMessageHandlerRunner extends message_handler_runner_1.MessageHa
         redis_smq_common_1.async.waterfall([
             (cb) => {
                 const { redis } = this.config;
-                redis_smq_common_1.RedisClient.getNewInstance(redis, (err, client) => {
+                (0, redis_smq_common_1.createClientInstance)(redis, (err, client) => {
                     if (err)
                         cb(err);
                     else if (!client)

package/dist/src/lib/consumer/consumer-message-handler/processing-queue.d.ts

@@ -1,8 +1,8 @@
 import { IRequiredConfig, TQueueParams } from '../../../../types';
 import { RedisClient } from 'redis-smq-common';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 export declare const processingQueue: {
-    cleanUpProcessingQueue(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, multi: TRedisClientMulti, cb: ICallback<void>): void;
-    setUpProcessingQueue(multi: TRedisClientMulti, queue: TQueueParams, consumerId: string): void;
+    cleanUpProcessingQueue(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, multi: IRedisClientMulti, cb: ICallback<void>): void;
+    setUpProcessingQueue(multi: IRedisClientMulti, queue: TQueueParams, consumerId: string): void;
     getQueueProcessingQueues(redisClient: RedisClient, queue: TQueueParams, cb: ICallback<Record<string, string>>): void;
 };

package/dist/src/lib/consumer/consumer-queues.d.ts

@@ -1,8 +1,8 @@
 import { TConsumerInfo, TQueueParams } from '../../../types';
 import { RedisClient } from 'redis-smq-common';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 export declare const consumerQueues: {
-    removeConsumer(multi: TRedisClientMulti, queue: TQueueParams, consumerId: string): void;
+    removeConsumer(multi: IRedisClientMulti, queue: TQueueParams, consumerId: string): void;
     getQueueConsumers(client: RedisClient, queue: TQueueParams, transform: boolean, cb: ICallback<Record<string, TConsumerInfo | string>>): void;
     getQueueConsumerIds(client: RedisClient, queue: TQueueParams, cb: ICallback<string[]>): void;
     countQueueConsumers(client: RedisClient, queue: TQueueParams, cb: ICallback<number>): void;

package/dist/src/lib/consumer/consumer.js

@@ -20,7 +20,7 @@ class Consumer extends base_1.Base {
         this.heartbeat = null;
         this.workerRunner = null;
         this.setUpHeartbeat = (cb) => {
-            redis_smq_common_1.RedisClient.getNewInstance(this.config.redis, (err, redisClient) => {
+            (0, redis_smq_common_1.createClientInstance)(this.config.redis, (err, redisClient) => {
                 if (err)
                     cb(err);
                 else if (!redisClient)

package/dist/src/lib/consumer/offline-consumers.d.ts

@@ -1,4 +1,4 @@
 import { IRequiredConfig } from '../../../types';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
-export declare function handleOfflineConsumer(config: IRequiredConfig, multi: TRedisClientMulti, redisClient: RedisClient, consumerId: string, cb: ICallback<void>): void;
+export declare function handleOfflineConsumer(config: IRequiredConfig, multi: IRedisClientMulti, redisClient: RedisClient, consumerId: string, cb: ICallback<void>): void;

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

@@ -20,7 +20,7 @@ class MessageManager {
     }
     static createInstance(config, cb) {
         const cfg = (0, configuration_1.getConfiguration)(config);
-        redis_smq_common_1.RedisClient.getNewInstance(cfg.redis, (err, client) => {
+        (0, redis_smq_common_1.createClientInstance)(cfg.redis, (err, client) => {
             if (err)
                 cb(err);
             else if (!client)

package/dist/src/lib/message-manager/message-storage/sorted-set.js

@@ -12,7 +12,7 @@ class SortedSet extends abstract_message_storage_1.AbstractMessageStorage {
         const multi = this.redisClient.multi();
         multi.hdel(keyMessages, messageId);
         multi.zrem(keyMessagesWeight, messageId);
-        this.redisClient.execMulti(multi, (err) => cb(err));
+        multi.exec((err) => cb(err));
     }
     fetchMessages(key, skip, take, cb) {
         this.validatePaginationParams(skip, take);
@@ -73,7 +73,7 @@ class SortedSet extends abstract_message_storage_1.AbstractMessageStorage {
         const multi = this.redisClient.multi();
         multi.del(keyMessages);
         multi.del(keyMessagesWeight);
-        this.redisClient.execMulti(multi, (err) => cb(err));
+        multi.exec((err) => cb(err));
     }
     getMessageById(key, id, cb) {
         const { keyMessages } = key;

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

@@ -1,4 +1,4 @@
 import { RedisClient } from 'redis-smq-common';
-import { ICallback, TRedisClientMulti } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { IRequiredConfig, TQueueParams } from '../../../types';
-export declare function initDeleteQueueTransaction(config: IRequiredConfig, redisClient: RedisClient, queueParams: TQueueParams, multi: TRedisClientMulti | undefined, cb: ICallback<TRedisClientMulti>): void;
+export declare function initDeleteQueueTransaction(config: IRequiredConfig, redisClient: RedisClient, queueParams: TQueueParams, multi: IRedisClientMulti | undefined, cb: ICallback<IRedisClientMulti>): void;

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

@@ -81,9 +81,9 @@ function initDeleteQueueTransaction(config, redisClient, queueParams, multi, cb)
                     const pQueues = processingQueues !== null && processingQueues !== void 0 ? processingQueues : [];
                     if (pQueues.length) {
                         keys.push(...pQueues);
-                        tx.srem(keyProcessingQueues, ...pQueues);
+                        tx.srem(keyProcessingQueues, pQueues);
                     }
-                    tx.del(...keys);
+                    tx.del(keys);
                     cb(null, tx);
                 }
             });

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

@@ -65,7 +65,7 @@ class Namespace {
                             if (err)
                                 cb(err);
                             else
-                                this.redisClient.execMulti(multi, (err) => cb(err));
+                                multi.exec((err) => cb(err));
                         });
                     }
                 });

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

@@ -21,7 +21,7 @@ class QueueManager {
     static createInstance(config, cb) {
         const cfg = (0, configuration_1.getConfiguration)(config);
         const redis = cfg.redis;
-        redis_smq_common_1.RedisClient.getNewInstance(redis, (err, client) => {
+        (0, redis_smq_common_1.createClientInstance)(redis, (err, client) => {
             if (err)
                 cb(err);
             else if (!client)

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

@@ -8,7 +8,7 @@ export declare class QueueRateLimit {
     constructor(config: IRequiredConfig, redisClient: RedisClient, logger: ICompatibleLogger);
     clear(queue: string | TQueueParams, cb: ICallback<void>): void;
     set(queue: string | TQueueParams, rateLimit: TQueueRateLimit, cb: ICallback<void>): void;
-    get(queue: string | TQueueParams, cb: ICallback<TQueueRateLimit>): void;
+    get(queue: string | TQueueParams, cb: ICallback<TQueueRateLimit | null>): void;
     static hasExceeded(redisClient: RedisClient, queue: TQueueParams, rateLimit: TQueueRateLimit, cb: ICallback<boolean>): void;
-    static get(config: IRequiredConfig, redisClient: RedisClient, queue: string | TQueueParams, cb: ICallback<TQueueRateLimit>): void;
+    static get(config: IRequiredConfig, redisClient: RedisClient, queue: string | TQueueParams, cb: ICallback<TQueueRateLimit | null>): void;
 }

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

@@ -17,7 +17,7 @@ class QueueRateLimit {
         const multi = this.redisClient.multi();
         multi.hdel(keyQueueSettings, keyQueueSettingsRateLimit);
         multi.del(keyQueueRateLimitCounter);
-        this.redisClient.execMulti(multi, (err) => cb(err));
+        multi.exec((err) => cb(err));
     }
     set(queue, rateLimit, cb) {
         const queueParams = queue_1.Queue.getParams(this.config, queue);

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

@@ -49,7 +49,7 @@ class Queue {
             else if (!multi)
                 cb(new redis_smq_common_1.errors.EmptyCallbackReplyError());
             else
-                this.redisClient.execMulti(multi, (err) => cb(err));
+                multi.exec((err) => cb(err));
         });
     }
     static getParams(config, queue) {

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

@@ -29,7 +29,7 @@ class DelayWorker extends redis_smq_common_1.Worker {
                             if (err)
                                 cb(err);
                             else
-                                this.redisClient.execMulti(multi, (err) => cb(err));
+                                multi.exec((err) => cb(err));
                         });
                     }
                     else

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

@@ -37,7 +37,7 @@ class RequeueWorker extends redis_smq_common_1.Worker {
                             if (err)
                                 cb(err);
                             else
-                                this.redisClient.execMulti(multi, (err) => cb(err));
+                                multi.exec((err) => cb(err));
                         });
                     }
                     else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.0.0-rc.3",
+  "version": "7.0.0-rc.6",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "bluebird": "3.7.2",
     "cron-parser": "3.5.0",
     "lodash": "4.17.21",
-    "redis-smq-common": "1.0.0-rc.3",
+    "redis-smq-common": "1.0.0-rc.11",
     "uuid": "8.3.2"
   },
   "devDependencies": {
@@ -91,6 +91,6 @@
   },
   "engineStrict": true,
   "engines": {
-    "node": "12 || ^14 || ^16"
+    "node": ">=14"
   }
 }