redis-smq 7.1.1 → 7.1.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 7.1.2 (2022-10-22)
+
+* fix(FanOutExchangeManager): fix unbindQueue() transaction handling (dec63de)
+* fix(FanOutExchangeManager): fix bindQueue() transaction handling (afbdde6)
+* docs(queues): fix typos (08f29c0)
+* docs(queues): add queues.md reference, clean up (3219eb8)
+* docs: improve documentation, add missing links (c740e11)
+
 ## 7.1.1 (2022-10-11)
 
 * docs(message-exchanges): update docs (19d7dd3)

package/README.md

@@ -18,20 +18,20 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 ## Features
 
 * **[High-performance message processing](/docs/performance.md)**.
-* **[Multi-Queue Producers](#producer-class) & [Multi-Queue Consumers](#consumer-class)**: Offering flexible Producer/Consumer models, with focus on simplicity and without tons of features. This can make RedisSMQ an ideal message broker for your microservices. 
-* **[Supports 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.
-* **[Supports Different Exchange Types](/docs/message-exchanges.md)**: RedisSMQ offers 3 types of exchanges: [Direct Exchange](/docs/message-exchanges.md#direct-exchange), [Topic Exchange](/docs/message-exchanges.md#topic-exchange), and [Fanout Exchange](/docs/message-exchanges.md#fanout-exchange) for publishing a message to one or multiple queues. 
+* **[Multi-Queue Producers](#producer) & [Multi-Queue Consumers](#consumer)**: Offering flexible Producer/Consumer models, with focus on simplicity and without tons of features. This can make RedisSMQ an ideal message broker for your microservices. 
+* **[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.
+* **[Different Exchange Types](/docs/message-exchanges.md)**: RedisSMQ offers 3 types of exchanges: [Direct Exchange](/docs/message-exchanges.md#direct-exchange), [Topic Exchange](/docs/message-exchanges.md#topic-exchange), and [Fanout Exchange](/docs/message-exchanges.md#fanout-exchange) for publishing a message to one or multiple queues. 
 * **[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.
+* **[Reliable Priority Queues](/docs/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](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)**: RedisSMQ comes with a built-in JSON logger, but can also use your application logger.
 * **[Configurable](/docs/configuration.md)**: Many options and features can be configured.
-* **[Supports Multiple Redis clients](/docs/configuration.md)**: Depending on your preferences, RedisSMQ can use either [node-redis v3](https://github.com/redis/node-redis/tree/v3.1.2), [node-redis v4](https://github.com/redis/node-redis), or [ioredis](https://github.com/luin/ioredis).
+* **[Multiple Redis clients](/docs/configuration.md)**: Depending on your preferences, RedisSMQ can use either [node-redis v3](https://github.com/redis/node-redis/tree/v3.1.2), [node-redis v4](https://github.com/redis/node-redis), or [ioredis](https://github.com/luin/ioredis).
 * **[Highly optimized](https://lgtm.com/projects/g/weyoss/redis-smq/context:javascript)**: Strongly-typed and implemented using pure callbacks, with small memory footprint and no memory leaks. See [Callback vs Promise vs Async/Await benchmarks](https://gist.github.com/weyoss/24f9ecbda175d943a48cb7ec38bde821).
 
 
@@ -47,22 +47,21 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 2. [Installation](#installation)
 3. [Configuration](#configuration)
 4. [Usage](#usage)
-   1. Basics
-       1. [Message Class](#message-class)
-       2. [Producer Class](#producer-class)
-       3. [Consumer Class](#consumer-class)
+   1. [Basics](#basics)
+       1. [Message](#message)
+       2. [Producer](#producer)
+       3. [Consumer](#consumer)
           1. [Message Acknowledgement](#message-acknowledgement)
-   2. Advanced Topics
+   2. [Advanced Topics](#advanced-topics)
       1. [Scheduling Messages](/docs/scheduling-messages.md)
-      2. [Priority Queues](/docs/priority-queues.md)
-      3. [Message Exchanges](/docs/message-exchanges.md)
-      4. [Queue Rate Limiting](/docs/queue-rate-limiting.md)
-      5. [Multiplexing](/docs/multiplexing.md)
-      6. [Message Manager](/docs/api/message-manager.md)
-      7. [Queue Manager](/docs/api/queue-manager.md)
-      8. [HTTP API](https://github.com/weyoss/redis-smq-monitor)
-      9. [Web UI](https://github.com/weyoss/redis-smq-monitor-client)
-      10. [Logs](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)
+      2. [Message Exchanges](/docs/message-exchanges.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](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)
@@ -93,9 +92,15 @@ See [Configuration](/docs/configuration.md) for more details.
 
 ## Usage
 
-Before producing/consuming a message to/from a queue, make sure that such queue exists. 
+### Basics
+
+RedisSMQ provides 3 classes in order to work with the message queue: `Message`, `Producer`, and `Consumer`.
+
+Producers and consumers exchange data using one or multiple queues that may be created using the [QueueManager](/docs/api/queue-manager.md).
+
+A queue is responsible for holding messages which are produced by producers and are delivered to consumers.
 
-You can create a queue, view existing queues, or delete a queue using the [QueueManager](/docs/api/queue-manager.md).
+RedisSMQ supports 2 types of queues: [LIFO Queues and Priority Queues](/docs/queues.md).
 
 ```javascript
 const { QueueManager } = require('redis-smq');
@@ -103,15 +108,14 @@ const config = require('./config')
 
 QueueManager.createInstance(config, (err, queueManager) => {
   if (err) console.log(err);
+  // Creating a LIFO queue
   else queueManager.queue.create('test_queue', false, (err) => console.log(err));
 })
 ```
 
-### Basics
-
-RedisSMQ provides 3 classes in order to work with the message queue: `Message`, `Producer`, and `Consumer`.
+See [Queues](/docs/queues.md) for more details.
 
-#### Message Class
+#### Message
 
 `Message` class is responsible for creating messages that may be published. 
 
@@ -124,21 +128,21 @@ const { Message } = require('redis-smq');
 const message = new Message();
 message
     .setBody({hello: 'world'})
-    .setTTL(3600000) // in millis
-    .setQueue('test_queue');
+    .setTTL(3600000)
+    .setRetryThreshold(5);
 ```
 
 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.
 
-#### Producer Class
+#### Producer
 
-A `Producer` instance allows you to publish a message to a queue. 
+A `Producer` instance allows to publish a message to a queue. 
 
-You can use a single `Producer` instance to produce messages, including messages with priority, to multiple queues.
+You can use a single `Producer` instance to produce messages, including messages with priority, to one or multiple queues.
 
-Before publishing a message do not forget to set the destination queue of the message using the [setQueue()](/docs/api/message.md#messageprototypesetqueue) method, otherwise an error will be returned.
+Before publishing a message do not forget to set an exchange for the message using [setQueue()](/docs/api/message.md#messageprototypesetqueue), [setTopic()](/docs/api/message.md#messageprototypesettopic), or [setFanOut()](/docs/api/message.md#messageprototypesetfanout). Otherwise, an error will be returned. See [Message Exchanges](/docs/message-exchanges.md) for more details.
 
 ```javascript
 'use strict';
@@ -150,8 +154,8 @@ producer.run((err) => {
    const message = new Message();
    message
            .setBody({hello: 'world'})
-           .setTTL(3600000) // in millis
-           .setQueue('test_queue');
+           .setTTL(3600000) // message expiration (in millis)
+           .setQueue('test_queue'); // setting up a direct exchange 
    message.getId() // null
    producer.produce(message, (err) => {
       if (err) console.log(err);
@@ -167,11 +171,11 @@ Starting with v7.0.6, before producing messages you need first to run your produ
 
 See [Producer Reference](/docs/api/producer.md) for more details.
 
-#### Consumer Class
+#### Consumer
 
 A `Consumer` instance can be used to receive and consume messages from one or multiple queues.
 
-To consume messages from a queue, the `Consumer` class provides the [consume()](/docs/api/consumer.md#consumerprototypeconsume) method which allows you to register a `message handler`. 
+To consume messages from a queue, the `Consumer` class provides the [consume()](/docs/api/consumer.md#consumerprototypeconsume) method which allows to register a `message handler`. 
 
 A `message handler` is a function that receives a delivered message from a given queue. 
 
@@ -225,8 +229,6 @@ See [Consumer Reference](/docs/api/consumer.md) for more details.
 
 * [Scheduling Messages](/docs/scheduling-messages.md)
 
-* [Priority Queues](/docs/priority-queues.md)
-
 * [Message Exchanges](/docs/message-exchanges.md)
 
 * [Queue Rate Limiting](/docs/queue-rate-limiting.md)

package/dist/src/lib/exchange/fan-out-exchange-manager.js

@@ -40,33 +40,28 @@ class FanOutExchangeManager {
         });
     }
     bindQueue(queue, exchange, cb) {
+        const exchangeParams = exchange.getBindingParams();
+        const queueParams = queue_1.Queue.getParams(this.config, queue);
+        const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        const { keyExchanges, keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchangeParams);
         redis_smq_common_1.async.waterfall([
+            (cb) => this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => cb(err)),
             (cb) => queue_1.Queue.getSettings(this.config, this.redisClient, queue, cb),
             (queueSettings, cb) => {
-                const exchangeParams = exchange.getBindingParams();
                 const currentExchangeParams = queueSettings.exchange;
                 if (currentExchangeParams === exchangeParams)
                     cb();
                 else {
-                    const { keyExchanges, keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchangeParams);
-                    const queueParams = queue_1.Queue.getParams(this.config, queue);
-                    const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
-                    this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => {
-                        if (err)
-                            cb(err);
-                        else {
-                            const multi = this.redisClient.multi();
-                            const queueParamsStr = JSON.stringify(queueParams);
-                            multi.sadd(keyExchanges, exchangeParams);
-                            multi.sadd(keyExchangeBindings, queueParamsStr);
-                            multi.hset(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE, exchangeParams);
-                            if (currentExchangeParams) {
-                                const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(currentExchangeParams);
-                                multi.srem(keyExchangeBindings, queueParamsStr);
-                            }
-                            multi.exec((err) => cb(err));
-                        }
-                    });
+                    const multi = this.redisClient.multi();
+                    const queueParamsStr = JSON.stringify(queueParams);
+                    multi.sadd(keyExchanges, exchangeParams);
+                    multi.sadd(keyExchangeBindings, queueParamsStr);
+                    multi.hset(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE, exchangeParams);
+                    if (currentExchangeParams) {
+                        const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(currentExchangeParams);
+                        multi.srem(keyExchangeBindings, queueParamsStr);
+                    }
+                    multi.exec((err) => cb(err));
                 }
             },
         ], (err) => {
@@ -77,28 +72,26 @@ class FanOutExchangeManager {
         });
     }
     unbindQueue(queue, exchange, cb) {
+        const exchangeName = exchange.getBindingParams();
+        const queueParams = queue_1.Queue.getParams(this.config, queue);
+        const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
+        const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(exchangeName);
         redis_smq_common_1.async.waterfall([
-            (cb) => queue_1.Queue.getSettings(this.config, this.redisClient, queue, cb),
-            (queueSettings, cb) => {
-                const queueParams = queue_1.Queue.getParams(this.config, queue);
-                const exchangeName = exchange.getBindingParams();
-                if (queueSettings.exchange !== exchangeName)
+            (cb) => this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => cb(err)),
+            (cb) => queue_1.Queue.getSettings(this.config, this.redisClient, queue, (err, settings) => {
+                if (err)
+                    cb(err);
+                else if ((settings === null || settings === void 0 ? void 0 : settings.exchange) !== exchangeName)
                     cb(new exchange_error_1.ExchangeError(`Queue ${queueParams.name}@${queueParams.ns} is not bound to [${exchangeName}] exchange.`));
-                else {
-                    const { keyExchangeBindings } = redis_keys_1.redisKeys.getFanOutExchangeKeys(queueSettings.exchange);
-                    const { keyQueues, keyQueueSettings } = redis_keys_1.redisKeys.getQueueKeys(queueParams);
-                    this.redisClient.watch([keyQueues, keyQueueSettings, keyExchangeBindings], (err) => {
-                        if (err)
-                            cb(err);
-                        else {
-                            const multi = this.redisClient.multi();
-                            const queueParamsStr = JSON.stringify(queueParams);
-                            multi.srem(keyExchangeBindings, queueParamsStr);
-                            multi.hdel(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE);
-                            multi.exec((err) => cb(err));
-                        }
-                    });
-                }
+                else
+                    cb();
+            }),
+            (cb) => {
+                const multi = this.redisClient.multi();
+                const queueParamsStr = JSON.stringify(queueParams);
+                multi.srem(keyExchangeBindings, queueParamsStr);
+                multi.hdel(keyQueueSettings, types_1.EQueueSettingType.EXCHANGE);
+                multi.exec((err) => cb(err));
             },
         ], (err) => {
             if (err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.1.1",
+  "version": "7.1.2",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",