redis-smq 7.2.2 → 8.0.0-rc.0

package/CHANGELOG.md

@@ -1,5 +1,73 @@
+
+
+## [8.0.0-rc.0](https://github.com/weyoss/redis-smq/compare/v7.2.3...v8.0.0-rc.0) (2023-11-20)
+
+
+### ⚠ BREAKING CHANGES
+
+* use latest redis-smq-common release, fix broken changes
+
+### Features
+
+* allow to track a published message by its ID ([5f702d2](https://github.com/weyoss/redis-smq/commit/5f702d251a5b1f43c0364d6ce96a667d4f79d700))
+
+
+### Bug Fixes
+
+* **exchange:** fix json argument typings for _fromJSON() ([55bf8cc](https://github.com/weyoss/redis-smq/commit/55bf8cca65fce23774a68e6aaac1b590bbc07ff4))
+
+
+### Documentation
+
+* add missing error classes reference, clean up ([106b6d0](https://github.com/weyoss/redis-smq/commit/106b6d0627b747e49d5d09499dda21912803298a))
+* **api:** improve IQueueProperties description ([4ffeee3](https://github.com/weyoss/redis-smq/commit/4ffeee30e4a119a4bf378a4e753b19ad60f62070))
+* fix empty links ([dfc4ae9](https://github.com/weyoss/redis-smq/commit/dfc4ae992be9b4145e100d8f063947c316b04f37))
+* fix javascript/typescript examples ([4cb2eb1](https://github.com/weyoss/redis-smq/commit/4cb2eb13055609ea05ed98b34a143feedb63ebc0))
+* **queue:** update IQueueProperties interface reference ([631f239](https://github.com/weyoss/redis-smq/commit/631f2393fedb7f33a20611e1a006b19c64a9fa93))
+* **README.md:** add pre-release notice ([458fc57](https://github.com/weyoss/redis-smq/commit/458fc57e8089b8aa2835783a8bfe642364989ff6))
+* **README.md:** fix typo ([3abf1e2](https://github.com/weyoss/redis-smq/commit/3abf1e2665c4ae5d3eb91b8166abc630cd9f039a))
+* **README.md:** update minimal supported Redis version ([2c3ea00](https://github.com/weyoss/redis-smq/commit/2c3ea00dd93266b59ee649ffc8ff9351708f925b))
+* **README:** fix heading hierarchy ([6dc0bd5](https://github.com/weyoss/redis-smq/commit/6dc0bd5ea10b42cc5a4ab1012c480f206e576edb))
+* update docs ([188679e](https://github.com/weyoss/redis-smq/commit/188679e9476c9c0ba979be500168567775e085f3))
+* update examples ([ac4b0b5](https://github.com/weyoss/redis-smq/commit/ac4b0b5d7d1d50ad10e9f5bcd825b28a51c37c40))
+
+
+### Codebase Refactoring
+
+* **queue:** use friendly keys for queue properties object ([9e88f54](https://github.com/weyoss/redis-smq/commit/9e88f54052a9b0bc89144e8d067f1818f0d32a13))
+* use latest redis-smq-common release, fix broken changes ([e347d4d](https://github.com/weyoss/redis-smq/commit/e347d4d148c3b104e7d73c9ef8d5bf796657c1d6))
+
+
+### Tests
+
+* fix broken changes from latest redis-smq-common ([30a6099](https://github.com/weyoss/redis-smq/commit/30a609981786cabd4d08e9277be5b0bab8ad86fb))
+* fix QueueMessageNotFoundError checking ([6053cee](https://github.com/weyoss/redis-smq/commit/6053ceef7b7922bbb58eaf91d4d3a15baea34bb4))
+* fix tests ([561f0d0](https://github.com/weyoss/redis-smq/commit/561f0d06f0c4f28e6338def878210f2704b718b0))
+
+
+### Misc
+
+* add npm scripts ([34b4883](https://github.com/weyoss/redis-smq/commit/34b4883fa65a3c0b75d019cd1aedda3d42ccfc63))
+* bump up redis-smq-common to v3.0.0-rc.6 ([f177b95](https://github.com/weyoss/redis-smq/commit/f177b95a84b1ab41304a8ceb568922e359c626b2))
+* bump up type-coverage to v2.27.0 ([5140727](https://github.com/weyoss/redis-smq/commit/5140727f59ebf820702b2822149d85a266ca4b5e))
+* fix incorrect imports ([ba82774](https://github.com/weyoss/redis-smq/commit/ba827746f1824191bd677919f3165e405ff8bcfc))
+* update both .gitignore and .npmignore files ([3e84387](https://github.com/weyoss/redis-smq/commit/3e8438758d65fec2afa4f8de11f25239f581c368))
+* update package-lock.json ([77c761a](https://github.com/weyoss/redis-smq/commit/77c761aec04e103bc6a60b01ae0393a9e9bf7e43))
+* update project copyright annotation ([4080ac0](https://github.com/weyoss/redis-smq/commit/4080ac0b76f418193391e20f5e8c294cac7671e9))
+
+
+### Continuous Integration
+
+* drop support for redis server 2.8 and 3 ([9ef8ade](https://github.com/weyoss/redis-smq/commit/9ef8adec08bf90d1cc27b9bbabe591bca25a7d8e))
+* update minimal supported versions for nodejs and redis ([13b3197](https://github.com/weyoss/redis-smq/commit/13b31977937c65aa989de8d715022d1afb5f0839))
+
 # CHANGELOG
 
+## 7.2.3 (2023-03-26)
+
+* test(consumer-heartbeat): update tests (4332153)
+* refactor(consumer-heartbeat): clean up and improve API (20fc1b1)
+
 ## 7.2.2 (2023-03-25)
 
 * test(workers): update tests (c22f1bb)
@@ -771,4 +839,3 @@ the configuration namespace is not set, the default namespace is used.
 * Rewritten RedisSMQ Monitor based on React and D3
 * RedisSMQ Monitor has split up from main repository and now maintained separately. 
 * Introduced changelog
-

package/README.md

@@ -17,240 +17,94 @@ 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) & [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. 
-* **[FIFO queues, LIFO queues, and Reliable Priority Queues](/docs/queues.md)**: Provides different queuing strategies that you may use depending on your needs and requirements.
-* **[Message Expiration](/docs/api/message.md#messageprototypesetttl)**: Allowing a message to expire if it has not been delivered within a given amount of time.
-* **[Message Consumption Timeout](/docs/api/message.md#messageprototypesetconsumetimeout)**: Allowing to set up a timeout for consuming messages.
-* **[Queue Rate Limiting](/docs/queue-rate-limiting.md)**: Allowing 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.
-* **[Multiplexing](/docs/multiplexing.md)**: A feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
+* **[High-performance message processing](docs/performance.md)**.
+* **[Multi-Queue Producers](docs/producing-messages.md) & [Multi-Queue Consumers](docs/consuming-messages.md)**: 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/classes/Message.md#setretrythreshold)**: 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.
+* **[FIFO queues, LIFO queues, and Reliable Priority Queues](docs/queues.md)**: Provides different queuing strategies that you may use depending on your needs and requirements.
+* **[Message Expiration](docs/api/classes/Message.md#setttl)**: Allowing a message to expire if it has not been delivered within a given amount of time.
+* **[Message Consumption Timeout](docs/api/classes/Message.md#setconsumetimeout)**: Allowing to set up a timeout for consuming messages.
+* **[Queue Rate Limiting](docs/queue-rate-limiting.md)**: Allowing 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.
+* **[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.
-* **[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).
+* **[Configurable](docs/configuration.md)**: Many options and features can be configured.
+* **[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).
 
-
-### RedisSMQ Use Case: Multi-Queue Producers & Multi-Queue Consumers
+## RedisSMQ Use Case: Multi-Queue Producers & Multi-Queue Consumers
 
  
 
-![RedisSMQ Overview](/docs/redis-smq-overview.png)
-
-## Table of Content
-
-1. [What's new?](#whats-new)
-2. [Installation](#installation)
-3. [Configuration](#configuration)
-4. [Usage](#usage)
-   1. [Basics](#basics)
-       1. [Message](#message)
-       2. [Producer](#producer)
-       3. [Consumer](#consumer)
-          1. [Message Acknowledgement](#message-acknowledgement)
-   2. [Advanced Topics](#advanced-topics)
-      1. [Scheduling Messages](/docs/scheduling-messages.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)
-8. [License](#license)
+![RedisSMQ Overview](docs/redis-smq-overview.png)
 
 ## What's new?
 
-**2023.01.06**
-
-:rocket: RedisSMQ v7.2 is released! Before this release RedisSMQ supported both LIFO queues and Priority queues. 
-With this new release, RedisSMQ now provides FIFO queues as a third option that completes the list of supported queue types. 
-For more details see [Queues](/docs/queues.md).
+:rocket: RedisSMQ v8 is coming soon!
 
 ## Installation
 
-```text
-npm install redis-smq-common redis-smq --save
+> Currently, RedisSMQ is going under heavy development. Pre-releases at any time may introduce new commits with breaking changes. To view the latest release reference see [RedisSMQ v7.2.3](https://github.com/weyoss/redis-smq/tree/v7.2.3)
+
+```shell
+npm i redis-smq@rc
 ```
 
 Considerations:
 
-- 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.
+- Minimal Node.js version is >= 18 (RedisSMQ is tested under current active LTS and maintenance LTS Node.js releases).
+- Minimal Redis server version is 4.0.0.
 
 ## Usage
 
-### 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).
+Producers and consumers exchange data using one or multiple queues that may be created using the [Queue Class](docs/api/classes/Queue.md).
 
 A queue is responsible for holding messages which are produced by producers and are delivered to consumers.
 
-```javascript
-const { QueueManager } = require('redis-smq');
-const { EQueueType } = require('redis-smq/dist/types');
-const config = require('./config')
-
-QueueManager.createInstance(config, (err, queueManager) => {
-  if (err) console.log(err);
-  // Creating a LIFO queue
-  else queueManager.queue.save('test_queue', EQueueType.LIFO_QUEUE, (err) => console.log(err));
-})
-```
-
-See [Queues](/docs/queues.md) for more details.
-
-#### Message
-
-`Message` class is responsible for creating messages that may be published. 
-
-A message can carry your application data, sometimes referred to as `message payload`, which may be delivered to a consumer to be processed asynchronously.  
-
-The message payload can be of any valid JSON data type. It may be a simple text message like `Hello world` or a complex data type like `{hello: 'world'}`.
+### Creating a queue
 
 ```javascript
-const { Message } = require('redis-smq');
-const message = new Message();
-message
-    .setBody({hello: 'world'})
-    .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
+const { Queue, EQueueType } = require('redis-smq');
 
-A `Producer` instance allows to publish a message to a queue. 
+const queue = new Queue();
 
-You can use a single `Producer` instance to produce messages, including messages with priority, to one or multiple queues.
+// Creating a LIFO queue
+queue.save('my_queue', EQueueType.LIFO_QUEUE, (err) => console.log(err));
+```
 
-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.
+### Producing a message
 
 ```javascript
-'use strict';
-const {Message, Producer} = require('redis-smq');
+const { Producer, Message } = require('redis-smq');
 
 const producer = new Producer();
-producer.run((err) => {
-   if (err) throw err;
-   const message = new Message();
-   message
-           .setBody({hello: 'world'})
-           .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);
-      else {
-         const msgId = message.getId(); // string
-         console.log('Successfully produced. Message ID is ', msgId);
-      }
-   });
-})
-```
-
-Starting with v7.0.6, before producing messages you need first to run your producer instance.
-
-See [Producer Reference](/docs/api/producer.md) for more details.
-
-#### 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 to register a `message handler`. 
-
-A `message handler` is a function that receives a delivered message from a given queue. 
-
-Message handlers can be registered at any time, before or after a consumer has been started. 
 
-In contrast to producers, consumers are not automatically started upon creation. To start a consumer use the [run()](/docs/api/consumer.md#consumerprototyperun) method.
+const message = new Message();
+message.setQueue('my_queue').setBody('Hello Word!')
 
-To stop consuming messages from a queue and to remove the associated `message handler` from your consumer, use the [cancel()](/docs/api/consumer.md#consumerprototypecancel) method. 
+producer.produce(message, (err) => console.log(err));
+```
 
-To shut down completely your consumer and tear down all message handlers, use the [shutdown()](/docs/api/consumer.md#consumerprototypeshutdown) method.
+### Consuming a message
 
 ```javascript
-'use strict';
-
 const { Consumer } = require('redis-smq');
 
 const consumer = new Consumer();
-
-const messageHandler = (msg, cb) => {
-   const payload = msg.getBody();
-   console.log('Message payload', payload);
-   cb(); // acknowledging the message
-};
-
-consumer.consume('test_queue', messageHandler, (err) => {
-   if (err) console.error(err);
-});
-
-consumer.run();
+const messageHandler = (message, cb) => {
+  console.log(message.getBody());
+  cb();
+}
+consumer.consume('my_queue', messageHandler, (err) => console.log(err));
 ```
 
-##### Message Acknowledgement
-
-Once a message is received, to acknowledge it, you invoke the callback function without arguments, as shown in the example above. 
-
-Message acknowledgment informs the MQ that the delivered message has been successfully consumed.
-
-If an error occurred while processing a message, you can unacknowledge it by passing in the error to the callback function.
-
-By default, unacknowledged messages are re-queued and delivered again unless **message retry threshold** is exceeded. 
-
-Delivered messages that couldn't be processed or can not be delivered to consumers are moved to a system generated queue called **dead-letter queue (DLQ)**.
-
-By default, RedisSMQ does not store acknowledged and dead-lettered messages for saving disk and memory spaces, 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.
-
-### Advanced Topics
-
-* [Scheduling Messages](/docs/scheduling-messages.md)
-
-* [Message Exchanges](/docs/message-exchanges.md)
-
-* [Queue Rate Limiting](/docs/queue-rate-limiting.md)
-
-* [Multiplexing](/docs/multiplexing.md)
-  
-* [Message Manager](/docs/api/message-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](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)
-
-## RedisSMQ Architecture
-
-* See [Architecture Overview](/docs/redis-smq-architecture.md).
-
-## Performance
+## Documentation
 
-See [Performance](/docs/performance.md) for more details.
+See [RedisSMQ Docs](docs/README.md) for more details.
 
 ## Contributing