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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 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,7 +15,7 @@
 
 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
 
@@ -30,7 +30,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 * **[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.
+* **[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%.
@@ -62,7 +62,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
       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)
+      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)
@@ -83,8 +83,8 @@ 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
 
@@ -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));
 })
@@ -233,7 +234,7 @@ See [Consumer Reference](docs/api/consumer.md) for more details.
 
 * [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
 

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/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.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.4",
   "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.8",
     "uuid": "8.3.2"
   },
   "devDependencies": {
@@ -91,6 +91,6 @@
   },
   "engineStrict": true,
   "engines": {
-    "node": "12 || ^14 || ^16"
+    "node": ">=14"
   }
 }