docs(handler): add support for raw command and event handling with RabbitMQ

Author: luisgomez29

docs/docs/reactive-commons/6-handling-domain-events.md

@@ -27,10 +27,12 @@ To effectively start listening events you should add the annotation `@EnableEven
 ```java
 @EnableEventListeners
 public class EventsHandler {
+
     public Mono<Void> handleEventA(DomainEvent<Object/*change for proper model*/> event) {
         System.out.println("event received: " + event.getName() + " ->" + event.getData());
         return Mono.empty();
     }
+
 }
 ```
 
@@ -55,9 +57,51 @@ Then you should create the handler like:
 ```java
 @EnableNotificationListener
 public class EventsHandler {
+
     public Mono<Void> handleEventA(DomainEvent<Object/*change for proper model*/> event) {
         System.out.println("event received: " + event.getName() + " ->" + event.getData());
         return Mono.empty();
     }
+
 }
-```
+```
+
+### Listening Raw Events
+
+If you need direct access to the raw message from RabbitMQ without domain model conversion, you can use `RawEventHandler`. 
+This approach applies to both domain events and notification events. Raw event handlers process all incoming events for the specified event name,
+giving you access to the message body, headers, and other low-level properties directly.
+
+#### Example for Raw Domain Events
+
+```java
+@Configuration
+public class HandlerRegistryConfiguration {
+
+    @Bean
+    public HandlerRegistry handlerRegistry(EventsHandler events) {
+        return HandlerRegistry.register()
+                .listenRawEvent("some.event.name", events::handleRawEventOrNotification)
+                .listenNotificationRawEvent("some.notification.event", events::handleRawEventOrNotification);
+    }
+}
+```
+
+The handler implementation receives a `RawMessage` which can be cast to `RabbitMessage` to access the underlying message properties:
+
+```java
+@EnableEventListeners
+@EnableNotificationListener
+public class EventsHandler {
+
+    public Mono<Void> handleRawEventOrNotification(RawMessage event) {
+        RabbitMessage rawMessage = (RabbitMessage) event;
+        System.out.println("RawEvent received: " + new String(rawMessage.getBody()));
+        System.out.println("Content Type: " + rawMessage.getProperties().getContentType());
+        System.out.println("Headers: " + rawMessage.getProperties().getHeaders());
+        // Process the raw event or notification
+        return Mono.empty();
+    }
+
+}
+```

docs/docs/reactive-commons/7-handling-commands.md

@@ -6,7 +6,7 @@ sidebar_position: 7
 
 ## HandlerRegistry configuration
 
-To listen a Command you should register it in the HandlerRegistry and make it available as a Bean
+To listen a Command you should register it in the HandlerRegistry and make it available as a Bean.
 
 ### Listening Commands
 
@@ -27,15 +27,52 @@ To effectively start listening commands you should add the annotation `@EnableCo
 ```java
 @EnableCommandListeners
 public class CommandsHandler {
+    
     public Mono<Void> handleCommandA(Command<Object/*change for proper model*/> command) {
         System.out.println("command received: " + command.getName() + " ->" + command.getData());
         return Mono.empty();
     }
+
 }
 ```
 
 As the model of commands is direct, a consumer always can send commands to the service provider, by this reason you may receive commands that you don`t have configured.
 
+### Listening Raw Commands
+
+If you need direct access to the raw message from RabbitMQ without domain model conversion, you can use `RawCommandHandler`.
+Raw command handlers process all incoming commands without filtering by command name. This is useful when you need to handle
+the message body, headers, or other low-level properties directly.
+
+```java
+@Configuration
+public class HandlerRegistryConfiguration {
+
+    @Bean
+    public HandlerRegistry handlerRegistry(CommandsHandler commands) {
+        return HandlerRegistry.register()
+                .handleRawCommand(commands::handleRawCommandA);
+    }
+}
+```
+
+The handler implementation receives a `RawMessage` which can be cast to `RabbitMessage` to access the underlying message properties:
+
+```java
+@EnableCommandListeners
+public class CommandsHandler {
+    
+    public Mono<Void> handleRawCommandA(RawMessage command) {
+        RabbitMessage rawMessage = (RabbitMessage) command;
+        System.out.println("RawEvent received: " + new String(rawMessage.getBody()));
+        System.out.println("Content Type: " + rawMessage.getProperties().getContentType());
+        System.out.println("Headers: " + rawMessage.getProperties().getHeaders());
+        // Process the raw message
+        return Mono.empty();
+    }
+}
+```
+
 ### Wildcards
 
 You may need to handle variable command names that have the same structure, in that case you can specfy a pattern with '*' wildcard, for example: