@nestjstools/messaging 2.16.1 → 2.17.1

package/README.md

@@ -110,7 +110,7 @@ export class SendMessageHandler implements IMessageHandler<SendMessage> {
    // use the `@DenormalizeMessage()` decorator on the parameter:
    // async handle(@DenormalizeMessage() message: SendMessage): Promise<MessageResponse | void> {
 
-  async handle(message: SendMessage): Promise<MessageResponse | void> {
+  async handle(message: SendMessage): Promise<object | void> {
     console.log(message.content);
     // Example handling logic
   }
@@ -144,7 +144,7 @@ export class AppController {
 }
 ```
 
-### Explanation:
+### Flow:
 
 1. **Flexible Dispatching**:
     - You can call the `dispatch` method from any layer (e.g., controller, service, or scheduled job). This example uses an HTTP `GET` endpoint for demonstration.
@@ -163,131 +163,6 @@ export class AppController {
 
 🛠️ Please ensure you're using a compatible setup when working with multiple handlers, as this could result in unexpected behavior.
 
----
-
-## RabbitMQ Integration: Messaging Configuration Example
-
----
-
-The `MessagingModule` provides out-of-the-box integration with **RabbitMQ**, enabling the use of **AMQP** channels alongside in-memory channels. The configuration below demonstrates **CQRS** by separating command and event buses, ensuring seamless integration of your application with RabbitMQ's flexible messaging capabilities for both **command** and **event handling** + command dispatching.
-
-## To make it works for rabbitmq
-We need to install rabbitmq extension for `@nestjstools/messaging`
-
-```bash
-npm install @nestjstools/messaging-rabbitmq-extension
-```
-
-or
-
-```bash
-yarn add @nestjstools/messaging-rabbitmq-extension
-```
-
-```typescript
-import { MessagingModule, InMemoryChannelConfig, AmqpChannelConfig, ExchangeType } from '@nestjstools/messaging';
-import { SendMessageHandler } from './handlers/send-message.handler';
-
-
-@Module({
-  imports: [
-    MessagingModule.forRoot({
-      buses: [
-        {
-          name: 'message.bus',
-          channels: ['my-channel'],
-        },
-        {
-          name: 'command-bus', // The naming is very flexible
-          channels: ['amqp-command'], // Be sure if you defined same channels name as you defined below 
-        },
-        {
-          name: 'event-bus',
-          channels: ['amqp-event'],
-        },
-      ],
-      channels: [
-        new InMemoryChannelConfig({
-          name: 'my-channel',
-          middlewares: [],
-        }),
-        new AmqpChannelConfig({
-          name: 'amqp-command',
-          connectionUri: 'amqp://guest:guest@localhost:5672/',
-          exchangeName: 'my_app_command.exchange',
-          bindingKeys: ['my_app.command.#'],
-          exchangeType: ExchangeType.TOPIC,
-          middlewares: [],
-          queue: 'my_app.command',
-          autoCreate: true, // Create exchange, queue & bind keys
-        }),
-        new AmqpChannelConfig({
-          name: 'amqp-event',
-          connectionUri: 'amqp://guest:guest@localhost:5672/',
-           exchangeName: 'my_app_event.exchange',
-           bindingKeys: ['my_app_event.#'],
-           exchangeType: ExchangeType.TOPIC,
-          queue: 'my_app.event',
-          avoidErrorsForNotExistedHandlers: true, // We can avoid errors if we don't have handler yet for the event
-          autoCreate: true,
-        }),
-      ],
-      debug: true,
-    }),
-  ],
-})
-export class AppModule {}
-```
-
----
-
-### Key Features:
-
-1. **Multiple Message Buses**:
-    - Configure distinct buses for **in-memory**, **commands**, and **events**:
-        - `message.bus` (in-memory).
-        - `command.message-bus` (AMQP command processing).
-        - `event.message-bus` (AMQP event processing).
-
-2. **In-Memory Channel**:
-    - Simple and lightweight channel suitable for non-persistent messaging or testing purposes.
-
-3. **AMQP Channels**:
-    - Fully integrated RabbitMQ channel configuration using `AmqpChannelConfig`.
-
-4. **Channel Details**:
-    - `connectionUri`: Specifies the RabbitMQ server connection.
-    - `exchangeName`: The AMQP exchange to publish or consume messages from.
-    - `bindingKeys`: Define message routing patterns using wildcards (e.g., `my_app.command.#`).
-    - `exchangeType`: Supports RabbitMQ exchange types such as `TOPIC`.
-    - `queue`: Specify a RabbitMQ queue to consume messages from.
-    - `autoCreate`: Automatically creates the exchange, queue, and bindings if they don’t exist.
-
-5. **Error Handling**:
-    - Use `avoidErrorsForNotExistedHandlers` in `amqp-event` to gracefully handle missing handlers for event messages.
-
-6. **Debug Mode**:
-    - Enable `debug: true` to assist in monitoring and troubleshooting messages.
-
-This configuration provides a solid foundation for integrating RabbitMQ as part of your messaging system. It facilitates the decoupling of commands, events, and in-memory operations, ensuring reliable and scalable communication across distributed systems.
-
----
-
-## Mapping Messages in RabbitMQ Channel
-
-### Topic Exchange
-For optimal routing, it's recommended to use routing keys as part of the binding key. For example, if you bind a queue with the key `my_app.command.#`, messages with routing keys like `my_app.command.domain.action` will automatically be routed to that queue. This ensures that any message with a routing key starting with `my_app.command` is directed to the appropriate queue.
-Here's a more concise and clear version of your explanation:
-
-### Direct Exchange
-Ensure your queue has defined binding keys, as messages will be routed to queues based on these keys. If no binding keys are defined, the routing key in RabbitMQ will default to the routing key specified in the handler.
-
-### Additional
-* You can override message routing using `AmqpMessageOptions`. This allows sending a message to a specified exchange and routing it with a custom key.
-    ```typescript
-    this.messageBus.dispatch(new RoutingMessage(new SendMessage('Hello Rabbit!'), 'app.command.execute', new AmqpMessageOptions('exchange_name', 'rabbitmq_routing_key_to_queue')));
-    ```
-
 ---
 ## Normalizers
 What is a Normalizer?
@@ -472,7 +347,7 @@ Here’s a table with the documentation for the `MessagingModule.forRoot` config
 
 ### Channels
 
-#### 1. **InMemoryChannelConfig**
+#### **InMemoryChannelConfig**
 
 | **Property**                           | **Description**                                                                                                                                                                                             | **Default Value** |
 |----------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|
@@ -481,23 +356,6 @@ Here’s a table with the documentation for the `MessagingModule.forRoot` config
 | **`avoidErrorsForNotExistedHandlers`** | Avoid errors if no handler is available for the message.                                                                                                                                                    | `false`           |
 | **`normalizer`**                       | Set your custom normalizer for messages                                                                                                                                                                     |                   |
 
-#### 2. **AmqpChannelConfig**
-
-| **Property**                           | **Description**                                                                  | **Default Value** |
-|----------------------------------------|----------------------------------------------------------------------------------|-------------------|
-| **`name`**                             | Name of the AMQP channel (e.g., `'amqp-command'`).                               |                   |
-| **`connectionUri`**                    | URI for the RabbitMQ connection, such as `'amqp://guest:guest@localhost:5672/'`. |                   |
-| **`exchangeName`**                     | The AMQP exchange name (e.g., `'my_app.exchange'`).                              |                   |
-| **`bindingKeys`**                      | The routing keys to bind to (e.g., `['my_app.command.#']`).                      | `[]`              |
-| **`exchangeType`**                     | Type of the RabbitMQ exchange (e.g., `TOPIC`).                                   |                   |
-| **`queue`**                            | The AMQP queue to consume messages from (e.g., `'my_app.command'`).              |                   |
-| **`autoCreate`**                       | Automatically creates the exchange, queue, and bindings if they don’t exist.     | `true`            |
-| **`enableConsumer`**                   | Enables or disables the consumer for this channel.                               | `true`            |
-| **`avoidErrorsForNotExistedHandlers`** | Avoid errors if no handler is available for the message.                         | `false`           |
-| **`normalizer`**                       | Set your custom normalizer for messages                                          |                   |
-
-This table provides a structured overview of the **`MessagingModule.forRoot`** configuration, with details about each property within **buses** and **channels** and their corresponding default values.
-
 ## Creating Your Own Channel and Bus
 This process allows you to define and integrate a custom **Channel** and **MessageBus** for your application, giving you complete flexibility and control over how messages are processed, dispatched, and consumed. Each step provides the necessary building blocks to create your own transport layer with full integration into the `MessagingModule`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjstools/messaging",
-  "version": "2.16.1",
+  "version": "2.17.1",
   "description": "Simplifies asynchronous and synchronous message handling with support for buses, handlers, channels, and consumers. Build scalable, decoupled applications with ease and reliability.",
   "author": "Sebastian Iwanczyszyn",
   "license": "MIT",