@rolandsall24/nest-mediator 0.6.0 → 0.7.0

package/README.md

@@ -4,12 +4,13 @@ A lightweight CQRS (Command Query Responsibility Segregation) mediator pattern i
 
 ## Features
 
-- Clean separation between Commands and Queries
+- Clean separation between Commands, Queries, and Events
 - Type-safe handlers with TypeScript
 - Decorator-based handler registration
 - Automatic handler discovery and registration
 - Pipeline Behaviors for cross-cutting concerns (logging, validation, etc.)
 - Type-Specific Behaviors - behaviors that only apply to specific request types (v0.6.0+)
+- **Domain Events with Critical/Non-Critical consumers (v0.7.0+)**
 - Built-in behaviors: Logging, Validation, Exception Handling, Performance Tracking
 - Built on top of NestJS dependency injection
 - Zero runtime dependencies beyond NestJS
@@ -33,6 +34,32 @@ This library requires TypeScript decorators to be enabled. Add the following to
 }
 ```
 
+## Upgrading to v0.7.0
+
+Version 0.7.0 introduces **Domain Events** with Critical and Non-Critical consumer support.
+
+### What's New
+
+- `IEvent` interface for domain events
+- `IEventConsumer<TEvent>` interface for event consumers
+- `ICriticalEventConsumer<TEvent>` interface for critical consumers with optional compensation
+- `@EventHandler(EventClass)` decorator to register consumers
+- `@Critical({ order: n })` decorator for critical consumers (run sequentially)
+- `@NonCritical()` decorator for non-critical consumers (fire-and-forget)
+- `mediatorBus.publish(event)` method to publish events
+- `EventCriticality` enum (`CRITICAL`, `NON_CRITICAL`)
+- **Saga-style compensation**: Critical consumers can define a `compensate()` method that runs in reverse order when a subsequent consumer fails
+- Internal architecture refactoring (MediatorBus now delegates to CommandBus, QueryBus, EventBus)
+
+### Backward Compatibility
+
+- **`IEventHandler` renamed to `IEventConsumer`**: `IEventHandler` is now a deprecated type alias. Update your imports:
+
+- **MediatorBus API unchanged**: The `send()`, `query()`, and `publish()` methods work exactly as before
+- **No breaking changes**: Existing command/query code continues to work without modifications
+
+---
+
 ## Upgrading to v0.6.0
 
 Version 0.6.0 introduces **Type-Specific Pipeline Behaviors** - behaviors that only apply to specific request types.
@@ -82,58 +109,6 @@ Existing behaviors without `@Handle()` on the method continue to work exactly as
 
 ---
 
-## Upgrading to v0.5.0
-
-Version 0.5.0 introduces **Pipeline Behaviors** while maintaining backward compatibility. Existing code using `NestMediatorModule.forRoot()` will continue to work without changes.
-
-### What's New
-
-- Pipeline behaviors for cross-cutting concerns (logging, validation, etc.)
-- Built-in behaviors: `LoggingBehavior`, `ValidationBehavior`, `ExceptionHandlingBehavior`, `PerformanceBehavior`
-- New `forRoot()` method for enabling behaviors
-- Custom `HandlerNotFoundException` for better error handling
-
-### Breaking Change Notice
-
-The `send()` and `query()` methods now throw `HandlerNotFoundException` instead of a generic `Error` when no handler is registered. This is **backward compatible** since `HandlerNotFoundException` extends `Error`, but you may want to update your error handling for more specific catches:
-
-```typescript
-// Before (still works)
-try {
-  await mediator.send(command);
-} catch (error) {
-  if (error instanceof Error) {
-    console.log(error.message); // Works as before
-  }
-}
-
-// After (optional - for more specific handling)
-import { HandlerNotFoundException } from '@rolandsall24/nest-mediator';
-
-try {
-  await mediator.send(command);
-} catch (error) {
-  if (error instanceof HandlerNotFoundException) {
-    console.log(`No handler for: ${error.requestName}`);
-  }
-}
-```
-
-### No Migration Required
-
-If you're using `NestMediatorModule.forRoot()`, no changes are needed. Pipeline behaviors are **opt-in** via `forRoot()`:
-
-```typescript
-// Existing code - works exactly as before (no behaviors)
-NestMediatorModule.forRoot()
-
-// New - opt-in to behaviors
-NestMediatorModule.forRoot({
-  enableLogging: true,
-  enableValidation: true,
-})
-```
-
 ## Quick Start
 
 ### 1. Import the Module
@@ -337,6 +312,236 @@ export class UserController {
 }
 ```
 
+### Domain Events
+
+Domain events notify other parts of the system when something important happens. They support two consumer types:
+
+- **Critical consumers**: Run sequentially in order. Must succeed for the operation to complete.
+- **Non-critical consumers**: Run in parallel after critical consumers complete. Fire-and-forget.
+
+#### 1. Define an Event
+
+```typescript
+import { IEvent } from '@rolandsall24/nest-mediator';
+
+export class OrderPlacedEvent implements IEvent {
+  constructor(
+    public readonly orderId: string,
+    public readonly customerId: string,
+    public readonly items: { productId: string; quantity: number }[],
+    public readonly total: number,
+  ) {}
+}
+```
+
+#### 2. Create Event Consumers
+
+**Critical consumer** (must succeed, runs in order):
+
+```typescript
+import { Injectable, Logger } from '@nestjs/common';
+import { EventHandler, IEventConsumer, Critical } from '@rolandsall24/nest-mediator';
+import { OrderPlacedEvent } from './order-placed.event';
+
+@Injectable()
+@EventHandler(OrderPlacedEvent)
+@Critical({ order: 1 })  // Runs first among critical consumers
+export class ValidateInventoryConsumer implements IEventConsumer<OrderPlacedEvent> {
+  private readonly logger = new Logger(ValidateInventoryConsumer.name);
+
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    this.logger.log(`Validating inventory for order ${event.orderId}`);
+    // Validate all items are in stock
+    // Throw error if validation fails - stops the event processing
+  }
+}
+```
+
+**Critical consumer with compensation** (implements rollback on failure):
+
+```typescript
+import { Injectable, Logger } from '@nestjs/common';
+import { EventHandler, ICriticalEventConsumer, Critical } from '@rolandsall24/nest-mediator';
+import { OrderPlacedEvent } from './order-placed.event';
+
+@Injectable()
+@EventHandler(OrderPlacedEvent)
+@Critical({ order: 2 })
+export class ReserveInventoryConsumer implements ICriticalEventConsumer<OrderPlacedEvent> {
+  private readonly logger = new Logger(ReserveInventoryConsumer.name);
+
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    this.logger.log(`Reserving inventory for order ${event.orderId}`);
+    // Reserve inventory in the database
+  }
+
+  // Called if a SUBSEQUENT critical consumer fails (e.g., ChargePayment at order 4)
+  async compensate(event: OrderPlacedEvent): Promise<void> {
+    this.logger.warn(`[COMPENSATE] Releasing inventory for order ${event.orderId}`);
+    // Release the reserved inventory
+  }
+}
+```
+
+**Non-critical consumer** (fire-and-forget):
+
+```typescript
+import { Injectable, Logger } from '@nestjs/common';
+import { EventHandler, IEventConsumer, NonCritical } from '@rolandsall24/nest-mediator';
+import { OrderPlacedEvent } from './order-placed.event';
+
+@Injectable()
+@EventHandler(OrderPlacedEvent)
+@NonCritical()  // Runs in background after critical consumers
+export class SendOrderConfirmationConsumer implements IEventConsumer<OrderPlacedEvent> {
+  private readonly logger = new Logger(SendOrderConfirmationConsumer.name);
+
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    this.logger.log(`Sending confirmation email for order ${event.orderId}`);
+    // Send email - failures are logged but don't affect the order
+  }
+}
+
+// Consumers without @Critical or @NonCritical default to non-critical
+@Injectable()
+@EventHandler(OrderPlacedEvent)
+export class TrackAnalyticsConsumer implements IEventConsumer<OrderPlacedEvent> {
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    // Track analytics - non-critical by default
+  }
+}
+```
+
+#### 3. Publish Events from Command Handlers
+
+The recommended pattern is to publish domain events from command handlers after the main operation succeeds:
+
+```typescript
+import { Injectable, Logger } from '@nestjs/common';
+import { CommandHandler, ICommandHandler, MediatorBus } from '@rolandsall24/nest-mediator';
+import { PlaceOrderCommand } from './place-order.command';
+import { OrderPlacedEvent } from '../events/order-placed.event';
+
+@Injectable()
+@CommandHandler(PlaceOrderCommand)
+export class PlaceOrderHandler implements ICommandHandler<PlaceOrderCommand> {
+  private readonly logger = new Logger(PlaceOrderHandler.name);
+
+  constructor(private readonly mediatorBus: MediatorBus) {}
+
+  async execute(command: PlaceOrderCommand): Promise<void> {
+    const orderId = `order-${Date.now()}`;
+
+    // 1. Process the order (validate, save to DB, etc.)
+    this.logger.log(`Processing order ${orderId}`);
+    await this.processOrder(orderId, command);
+
+    // 2. Publish domain event after successful processing
+    // Critical consumers run sequentially, non-critical run in background
+    const result = await this.mediatorBus.publish(
+      new OrderPlacedEvent(
+        orderId,
+        command.customerId,
+        command.items,
+        command.total,
+      ),
+    );
+
+    this.logger.log(
+      `Order ${orderId} completed. Critical: ${result.criticalSucceeded}, Non-critical dispatched: ${result.nonCriticalDispatched}`,
+    );
+  }
+
+  private async processOrder(orderId: string, command: PlaceOrderCommand): Promise<void> {
+    // Order processing logic here
+  }
+}
+```
+
+#### 4. Event Execution Flow
+
+```
+publish(OrderPlacedEvent)
+    │
+    ├─► Critical Consumers (sequential, awaited)
+    │   ├─► ValidateInventoryConsumer (order: 1) ✓
+    │   ├─► ReserveInventoryConsumer (order: 2) ✓  [has compensate()]
+    │   ├─► CreateOrderRecordConsumer (order: 3) ✓ [has compensate()]
+    │   └─► ChargePaymentConsumer (order: 4) ✗ FAILS
+    │
+    │   On failure → Run compensations in REVERSE order:
+    │   ├─► CreateOrderRecordConsumer.compensate() - deletes order
+    │   └─► ReserveInventoryConsumer.compensate() - releases inventory
+    │   Then throw original error
+    │
+    └─► Non-Critical Consumers (parallel, fire-and-forget)
+        ├─► SendOrderConfirmationConsumer
+        ├─► NotifyWarehouseConsumer
+        └─► TrackAnalyticsConsumer
+
+        Only runs if ALL critical consumers succeed
+        Failures logged but don't affect the result
+```
+
+#### 5. Compensation Pattern (Saga)
+
+Critical consumers can implement the `ICriticalEventConsumer` interface with an optional `compensate()` method to support saga-style rollback:
+
+```typescript
+import { ICriticalEventConsumer, EventHandler, Critical } from '@rolandsall24/nest-mediator';
+
+@Injectable()
+@EventHandler(OrderPlacedEvent)
+@Critical({ order: 3 })
+export class CreateOrderRecordConsumer implements ICriticalEventConsumer<OrderPlacedEvent> {
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    // Create order in database
+    await this.orderRepository.create({
+      id: event.orderId,
+      customerId: event.customerId,
+      items: event.items,
+      total: event.total,
+    });
+  }
+
+  async compensate(event: OrderPlacedEvent): Promise<void> {
+    // Rollback: delete the order record
+    await this.orderRepository.delete(event.orderId);
+  }
+}
+```
+
+**Compensation rules:**
+- Only called when a **subsequent** critical consumer fails (not if this consumer fails)
+- Runs in **reverse order** (last succeeded → first succeeded)
+- Receives the same event instance passed to `handle()`
+- Should be **idempotent** - safe to run multiple times
+- Errors in compensations are logged but don't stop other compensations
+- Non-critical consumers don't need compensation (they're fire-and-forget)
+
+#### 6. Register Event Consumers
+
+Add consumers to your module providers - they're auto-discovered via `@EventHandler`:
+
+```typescript
+@Module({
+  imports: [NestMediatorModule.forRoot()],
+  providers: [
+    // Command handlers
+    PlaceOrderHandler,
+
+    // Event consumers - auto-discovered
+    ValidateInventoryConsumer,
+    ReserveInventoryConsumer,
+    CreateOrderRecordConsumer,
+    SendOrderConfirmationConsumer,
+    NotifyWarehouseConsumer,
+    TrackAnalyticsConsumer,
+  ],
+})
+export class AppModule {}
+```
+
 ## Complete Example
 
 Here's a complete example following Domain-Driven Design principles with proper separation of concerns:
@@ -732,6 +937,63 @@ export interface IPipelineBehavior<TRequest = any, TResponse = any> {
 }
 ```
 
+#### `IEvent`
+
+Marker interface for domain events.
+
+```typescript
+export interface IEvent {}
+```
+
+#### `IEventConsumer<TEvent>`
+
+Interface for event consumers (non-critical or critical without compensation).
+
+```typescript
+export interface IEventConsumer<TEvent extends IEvent> {
+  handle(event: TEvent): Promise<void>;
+}
+```
+
+#### `ICriticalEventConsumer<TEvent>`
+
+Interface for critical event consumers with optional compensation support (saga pattern).
+
+```typescript
+export interface ICriticalEventConsumer<TEvent extends IEvent> extends IEventConsumer<TEvent> {
+  /**
+   * Compensate/rollback the work done by handle().
+   * Called when a subsequent critical consumer fails.
+   * Should be idempotent and derive state from the event.
+   */
+  compensate?(event: TEvent): Promise<void>;
+}
+```
+
+#### `EventPublishResult`
+
+Result returned by `publish()`.
+
+```typescript
+export interface EventPublishResult {
+  totalHandlers: number;
+  criticalSucceeded: number;
+  nonCriticalDispatched: number;
+  compensationsRun: number;  // Number of compensations executed on failure
+}
+```
+
+#### `EventCriticality`
+
+Enum for event consumer criticality.
+
+```typescript
+export enum EventCriticality {
+  CRITICAL = 'critical',
+  NON_CRITICAL = 'non-critical',
+}
+```
+
 ### Decorators
 
 #### `@CommandHandler(command)`
@@ -799,11 +1061,36 @@ Excludes specific pipeline behaviors from a command or query.
 - **Usage**: Apply to command or query classes
 - **Works with**: Both built-in behaviors and custom behaviors
 
+#### `@EventHandler(event)`
+
+Marks a class as an event consumer.
+
+- **Parameters**: `event` - The event class this consumer handles
+- **Usage**: Apply to consumer classes that implement `IEventConsumer`
+
+#### `@Critical(options?)`
+
+Marks an event consumer as critical. Critical consumers run sequentially in order.
+
+- **Parameters**:
+  - `options.order` - Execution order among critical consumers (lower numbers first, default: 0)
+- **Usage**: Apply to consumer classes alongside `@EventHandler`
+- **Behavior**: If a critical consumer fails, remaining critical consumers are skipped and non-critical consumers don't run
+
+#### `@NonCritical()`
+
+Marks an event consumer as non-critical. Non-critical consumers run in parallel after critical consumers complete.
+
+- **Parameters**: None
+- **Usage**: Apply to consumer classes alongside `@EventHandler`
+- **Behavior**: Fire-and-forget - failures are logged but don't affect the publish result
+- **Note**: Consumers without `@Critical` or `@NonCritical` default to non-critical
+
 ### Services
 
 #### `MediatorBus`
 
-The main service for sending commands and queries.
+The main service for sending commands, queries, and events.
 
 ##### Methods
 
@@ -813,7 +1100,7 @@ Sends a command to its registered handler.
 
 - **Parameters**: `command` - The command instance to execute
 - **Returns**: Promise that resolves when the command is executed
-- **Throws**: Error if no handler is registered for the command
+- **Throws**: `HandlerNotFoundException` if no handler is registered for the command
 
 **`query<TQuery, TResult>(query: TQuery): Promise<TResult>`**
 
@@ -821,7 +1108,18 @@ Executes a query through its registered handler.
 
 - **Parameters**: `query` - The query instance to execute
 - **Returns**: Promise that resolves with the query result
-- **Throws**: Error if no handler is registered for the query
+- **Throws**: `HandlerNotFoundException` if no handler is registered for the query
+
+**`publish<TEvent>(event: TEvent): Promise<EventPublishResult>`**
+
+Publishes an event to all registered consumers.
+
+- **Parameters**: `event` - The event instance to publish
+- **Returns**: Promise with `EventPublishResult` containing:
+  - `totalHandlers` - Total number of consumers
+  - `criticalSucceeded` - Number of critical consumers that completed
+  - `nonCriticalDispatched` - Number of non-critical consumers dispatched
+- **Throws**: Error if any critical consumer fails
 
 ### Module Configuration
 

package/dist/lib/decorators/event-criticality.decorator.d.ts

@@ -0,0 +1,61 @@
+export { EventCriticality, EventCriticalityMetadata } from '../interfaces/event-criticality.interface.js';
+export declare const EVENT_CRITICALITY_METADATA = "EVENT_CRITICALITY_METADATA";
+/**
+ * Options for critical event handlers
+ */
+export interface CriticalOptions {
+    /**
+     * Execution order within critical handlers.
+     * Lower numbers execute first.
+     * Default: 0
+     */
+    order?: number;
+}
+/**
+ * Decorator to mark an event handler as critical.
+ * Critical handlers:
+ * - Run sequentially in the order specified
+ * - Must complete before non-critical handlers start
+ * - If one fails, the publish operation fails (remaining critical handlers are skipped)
+ * - Are awaited by the caller
+ *
+ * @param options - Optional configuration (order)
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(OrderPlacedEvent)
+ * @Critical({ order: 1 })
+ * export class ReserveInventoryHandler implements IEventConsumer<OrderPlacedEvent> {
+ *   async handle(event: OrderPlacedEvent): Promise<void> {
+ *     await this.inventoryService.reserve(event.items);
+ *   }
+ * }
+ * ```
+ */
+export declare const Critical: (options?: CriticalOptions) => ClassDecorator;
+/**
+ * Decorator to explicitly mark an event handler as non-critical.
+ * Non-critical handlers:
+ * - Run in parallel after all critical handlers complete
+ * - Fire and forget (not awaited by the caller)
+ * - Failures are logged but don't affect the publish result
+ * - Don't block the caller
+ *
+ * Note: Handlers without @Critical or @NonCritical are non-critical by default.
+ *
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(OrderPlacedEvent)
+ * @NonCritical()
+ * export class SendOrderConfirmationEmail implements IEventConsumer<OrderPlacedEvent> {
+ *   async handle(event: OrderPlacedEvent): Promise<void> {
+ *     await this.emailService.send(event.customerEmail, 'order_confirmed');
+ *   }
+ * }
+ * ```
+ */
+export declare const NonCritical: () => ClassDecorator;
+//# sourceMappingURL=event-criticality.decorator.d.ts.map

package/dist/lib/decorators/event-criticality.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-criticality.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/event-criticality.decorator.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAE1G,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAS,eAAoB,KAAG,cAMxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,QAAO,cAM9B,CAAC"}

package/dist/lib/decorators/event-criticality.decorator.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonCritical = exports.Critical = exports.EVENT_CRITICALITY_METADATA = exports.EventCriticality = void 0;
+const common_1 = require("@nestjs/common");
+const event_criticality_interface_js_1 = require("../interfaces/event-criticality.interface.js");
+// Re-export types for backward compatibility
+var event_criticality_interface_js_2 = require("../interfaces/event-criticality.interface.js");
+Object.defineProperty(exports, "EventCriticality", { enumerable: true, get: function () { return event_criticality_interface_js_2.EventCriticality; } });
+exports.EVENT_CRITICALITY_METADATA = 'EVENT_CRITICALITY_METADATA';
+/**
+ * Decorator to mark an event handler as critical.
+ * Critical handlers:
+ * - Run sequentially in the order specified
+ * - Must complete before non-critical handlers start
+ * - If one fails, the publish operation fails (remaining critical handlers are skipped)
+ * - Are awaited by the caller
+ *
+ * @param options - Optional configuration (order)
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(OrderPlacedEvent)
+ * @Critical({ order: 1 })
+ * export class ReserveInventoryHandler implements IEventConsumer<OrderPlacedEvent> {
+ *   async handle(event: OrderPlacedEvent): Promise<void> {
+ *     await this.inventoryService.reserve(event.items);
+ *   }
+ * }
+ * ```
+ */
+const Critical = (options = {}) => {
+    const metadata = {
+        criticality: event_criticality_interface_js_1.EventCriticality.CRITICAL,
+        order: options.order ?? 0,
+    };
+    return (0, common_1.SetMetadata)(exports.EVENT_CRITICALITY_METADATA, metadata);
+};
+exports.Critical = Critical;
+/**
+ * Decorator to explicitly mark an event handler as non-critical.
+ * Non-critical handlers:
+ * - Run in parallel after all critical handlers complete
+ * - Fire and forget (not awaited by the caller)
+ * - Failures are logged but don't affect the publish result
+ * - Don't block the caller
+ *
+ * Note: Handlers without @Critical or @NonCritical are non-critical by default.
+ *
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(OrderPlacedEvent)
+ * @NonCritical()
+ * export class SendOrderConfirmationEmail implements IEventConsumer<OrderPlacedEvent> {
+ *   async handle(event: OrderPlacedEvent): Promise<void> {
+ *     await this.emailService.send(event.customerEmail, 'order_confirmed');
+ *   }
+ * }
+ * ```
+ */
+const NonCritical = () => {
+    const metadata = {
+        criticality: event_criticality_interface_js_1.EventCriticality.NON_CRITICAL,
+        order: 0,
+    };
+    return (0, common_1.SetMetadata)(exports.EVENT_CRITICALITY_METADATA, metadata);
+};
+exports.NonCritical = NonCritical;
+//# sourceMappingURL=event-criticality.decorator.js.map

package/dist/lib/decorators/event-criticality.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-criticality.decorator.js","sourceRoot":"","sources":["../../../src/lib/decorators/event-criticality.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAC7C,iGAGsD;AAEtD,6CAA6C;AAC7C,+FAA0G;AAAjG,kIAAA,gBAAgB,OAAA;AAEZ,QAAA,0BAA0B,GAAG,4BAA4B,CAAC;AAcvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACI,MAAM,QAAQ,GAAG,CAAC,UAA2B,EAAE,EAAkB,EAAE;IACxE,MAAM,QAAQ,GAA6B;QACzC,WAAW,EAAE,iDAAgB,CAAC,QAAQ;QACtC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;KAC1B,CAAC;IACF,OAAO,IAAA,oBAAW,EAAC,kCAA0B,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC,CAAC;AANW,QAAA,QAAQ,YAMnB;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,MAAM,WAAW,GAAG,GAAmB,EAAE;IAC9C,MAAM,QAAQ,GAA6B;QACzC,WAAW,EAAE,iDAAgB,CAAC,YAAY;QAC1C,KAAK,EAAE,CAAC;KACT,CAAC;IACF,OAAO,IAAA,oBAAW,EAAC,kCAA0B,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC,CAAC;AANW,QAAA,WAAW,eAMtB"}

package/dist/lib/decorators/event-handler.decorator.d.ts

@@ -0,0 +1,21 @@
+import { IEvent } from '../interfaces/index.js';
+export declare const EVENT_HANDLER_METADATA = "EVENT_HANDLER_METADATA";
+/**
+ * Decorator to mark a class as an event consumer.
+ * Multiple consumers can subscribe to the same event.
+ *
+ * @param event - The event class that this consumer handles
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(UserCreatedEvent)
+ * export class SendWelcomeEmailConsumer implements IEventConsumer<UserCreatedEvent> {
+ *   async handle(event: UserCreatedEvent): Promise<void> {
+ *     await this.emailService.sendWelcome(event.userEmail);
+ *   }
+ * }
+ * ```
+ */
+export declare const EventHandler: (event: new (...args: any[]) => IEvent) => ClassDecorator;
+//# sourceMappingURL=event-handler.decorator.d.ts.map

package/dist/lib/decorators/event-handler.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/event-handler.decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,KACpC,cAEF,CAAC"}

package/dist/lib/decorators/event-handler.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = exports.EVENT_HANDLER_METADATA = void 0;
+const common_1 = require("@nestjs/common");
+exports.EVENT_HANDLER_METADATA = 'EVENT_HANDLER_METADATA';
+/**
+ * Decorator to mark a class as an event consumer.
+ * Multiple consumers can subscribe to the same event.
+ *
+ * @param event - The event class that this consumer handles
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(UserCreatedEvent)
+ * export class SendWelcomeEmailConsumer implements IEventConsumer<UserCreatedEvent> {
+ *   async handle(event: UserCreatedEvent): Promise<void> {
+ *     await this.emailService.sendWelcome(event.userEmail);
+ *   }
+ * }
+ * ```
+ */
+const EventHandler = (event) => {
+    return (0, common_1.SetMetadata)(exports.EVENT_HANDLER_METADATA, event);
+};
+exports.EventHandler = EventHandler;
+//# sourceMappingURL=event-handler.decorator.js.map

package/dist/lib/decorators/event-handler.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.decorator.js","sourceRoot":"","sources":["../../../src/lib/decorators/event-handler.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAGhC,QAAA,sBAAsB,GAAG,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACI,MAAM,YAAY,GAAG,CAC1B,KAAqC,EACrB,EAAE;IAClB,OAAO,IAAA,oBAAW,EAAC,8BAAsB,EAAE,KAAK,CAAC,CAAC;AACpD,CAAC,CAAC;AAJW,QAAA,YAAY,gBAIvB"}

package/dist/lib/decorators/index.d.ts

@@ -2,4 +2,6 @@ export * from './command-handler.decorator.js';
 export * from './query-handler.decorator.js';
 export * from './pipeline-behavior.decorator.js';
 export * from './skip-behavior.decorator.js';
+export * from './event-handler.decorator.js';
+export * from './event-criticality.decorator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/decorators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC"}

package/dist/lib/decorators/index.js

@@ -18,4 +18,6 @@ __exportStar(require("./command-handler.decorator.js"), exports);
 __exportStar(require("./query-handler.decorator.js"), exports);
 __exportStar(require("./pipeline-behavior.decorator.js"), exports);
 __exportStar(require("./skip-behavior.decorator.js"), exports);
+__exportStar(require("./event-handler.decorator.js"), exports);
+__exportStar(require("./event-criticality.decorator.js"), exports);
 //# sourceMappingURL=index.js.map