@rolandsall24/nest-mediator 0.4.3 → 0.5.0

package/README.md

@@ -8,6 +8,8 @@ A lightweight CQRS (Command Query Responsibility Segregation) mediator pattern i
 - Type-safe handlers with TypeScript
 - Decorator-based handler registration
 - Automatic handler discovery and registration
+- **Pipeline Behaviors** for cross-cutting concerns (logging, validation, etc.)
+- Built-in behaviors: Logging, Validation, Exception Handling, Performance Tracking
 - Built on top of NestJS dependency injection
 - Zero runtime dependencies beyond NestJS
 
@@ -30,6 +32,58 @@ This library requires TypeScript decorators to be enabled. Add the following to
 }
 ```
 
+## 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 `forRootAsync()` 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 `forRootAsync()`:
+
+```typescript
+// Existing code - works exactly as before (no behaviors)
+NestMediatorModule.forRoot()
+
+// New - opt-in to behaviors
+NestMediatorModule.forRootAsync({
+  enableLogging: true,
+  enableValidation: true,
+})
+```
+
 ## Quick Start
 
 ### 1. Import the Module
@@ -44,6 +98,7 @@ import { GetUserQueryHandler } from './handlers/get-user-query.handler';
 
 @Module({
   imports: [
+    // Basic setup
     NestMediatorModule.forRoot(),
   ],
   providers: [
@@ -56,7 +111,26 @@ import { GetUserQueryHandler } from './handlers/get-user-query.handler';
 export class AppModule {}
 ```
 
-**How it works**: The module uses NestJS's `DiscoveryService` to automatically discover and register all providers decorated with `@CommandHandler` or `@QueryHandler`. Simply add your handlers to the module's `providers` array and they will be automatically registered with the mediator!
+Or with built-in pipeline behaviors enabled:
+
+```typescript
+@Module({
+  imports: [
+    NestMediatorModule.forRootAsync({
+      enableLogging: true,           // Log request handling with timing
+      enableValidation: true,        // Validate requests with class-validator
+      enableExceptionHandling: true, // Centralized exception logging
+    }),
+  ],
+  providers: [
+    CreateUserCommandHandler,
+    GetUserQueryHandler,
+  ],
+})
+export class AppModule {}
+```
+
+**How it works**: The module uses NestJS's `DiscoveryService` to automatically discover and register all providers decorated with `@CommandHandler`, `@QueryHandler`, or `@PipelineBehavior`. Simply add your handlers to the module's `providers` array and they will be automatically registered with the mediator!
 
 ## Usage
 
@@ -510,7 +584,12 @@ import { UserPersistenceAdapter } from './infrastructure/persistence/user/user-p
 
 @Module({
   imports: [
-    NestMediatorModule.forRoot(),
+    // Enable pipeline behaviors for logging, validation, and error handling
+    NestMediatorModule.forRootAsync({
+      enableLogging: true,
+      enableValidation: true,
+      enableExceptionHandling: true,
+    }),
   ],
   controllers: [UserController],
   providers: [
@@ -593,6 +672,16 @@ export interface IQueryHandler<TQuery extends IQuery, TResult = any> {
 }
 ```
 
+#### `IPipelineBehavior<TRequest, TResponse>`
+
+Interface for pipeline behaviors (cross-cutting concerns).
+
+```typescript
+export interface IPipelineBehavior<TRequest = any, TResponse = any> {
+  handle(request: TRequest, next: () => Promise<TResponse>): Promise<TResponse>;
+}
+```
+
 ### Decorators
 
 #### `@CommandHandler(command)`
@@ -609,6 +698,25 @@ Marks a class as a query handler.
 - **Parameters**: `query` - The query class this handler handles
 - **Usage**: Apply to handler classes that implement `IQueryHandler`
 
+#### `@PipelineBehavior(options?)`
+
+Marks a class as a pipeline behavior.
+
+- **Parameters**:
+  - `options.priority` - Execution order (lower numbers execute first, default: 0)
+  - `options.scope` - `'command'`, `'query'`, or `'all'` (default: `'all'`)
+- **Usage**: Apply to behavior classes that implement `IPipelineBehavior`
+
+#### `@SkipBehavior(behavior | behaviors[])`
+
+Excludes specific pipeline behaviors from a command or query.
+
+- **Parameters**:
+  - Single behavior class: `@SkipBehavior(PerformanceBehavior)`
+  - Array of behavior classes: `@SkipBehavior([PerformanceBehavior, LoggingBehavior])`
+- **Usage**: Apply to command or query classes
+- **Works with**: Both built-in behaviors and custom behaviors
+
 ### Services
 
 #### `MediatorBus`
@@ -633,6 +741,388 @@ Executes a query through its registered handler.
 - **Returns**: Promise that resolves with the query result
 - **Throws**: Error if no handler is registered for the query
 
+### Module Configuration
+
+#### `NestMediatorModule.forRoot()`
+
+Basic module registration with no built-in behaviors.
+
+#### `NestMediatorModule.forRootAsync(options)`
+
+Module registration with configuration options.
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enableLogging` | boolean | false | Enable request/response logging |
+| `enableValidation` | boolean | false | Enable class-validator validation |
+| `enableExceptionHandling` | boolean | false | Enable centralized exception logging |
+| `enablePerformanceTracking` | boolean | false | Enable slow request warnings |
+| `performanceThresholdMs` | number | 500 | Threshold for slow request warnings |
+| `behaviors` | Type[] | [] | Additional custom behaviors to register |
+
+## Pipeline Behaviors
+
+Pipeline behaviors allow you to add cross-cutting concerns (like logging, validation, caching) that execute around every command and query handler.
+
+### Enabling Built-in Behaviors
+
+```typescript
+import { Module } from '@nestjs/common';
+import { NestMediatorModule } from '@rolandsall24/nest-mediator';
+
+@Module({
+  imports: [
+    NestMediatorModule.forRootAsync({
+      enableLogging: true,           // Logs request handling with timing
+      enableValidation: true,        // Validates requests using class-validator
+      enableExceptionHandling: true, // Centralized exception logging
+      enablePerformanceTracking: true, // Warns on slow requests
+      performanceThresholdMs: 500,   // Threshold for slow request warnings
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Built-in Behaviors
+
+| Behavior | Priority | Description |
+|----------|----------|-------------|
+| `ExceptionHandlingBehavior` | -100 | Catches and logs all exceptions |
+| `LoggingBehavior` | 0 | Logs request handling with timing |
+| `PerformanceBehavior` | 10 | Warns when requests exceed threshold |
+| `ValidationBehavior` | 100 | Validates requests using class-validator |
+
+### Creating Custom Behaviors
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { IPipelineBehavior, PipelineBehavior } from '@rolandsall24/nest-mediator';
+
+@Injectable()
+@PipelineBehavior({ priority: 50, scope: 'all' })
+export class MyCustomBehavior<TRequest, TResponse>
+  implements IPipelineBehavior<TRequest, TResponse> {
+
+  async handle(
+    request: TRequest,
+    next: () => Promise<TResponse>
+  ): Promise<TResponse> {
+    // Pre-processing logic
+    console.log('Before handler:', request);
+
+    // Call the next behavior or handler
+    const response = await next();
+
+    // Post-processing logic
+    console.log('After handler:', response);
+
+    return response;
+  }
+}
+```
+
+### Behavior Options
+
+```typescript
+@PipelineBehavior({
+  priority: 50,      // Lower numbers execute first (outermost)
+  scope: 'command',  // 'command', 'query', or 'all'
+})
+```
+
+**Priority Guidelines:**
+- `-100 to -1`: Exception handling (outermost)
+- `0 to 99`: Logging, performance tracking
+- `100 to 199`: Validation
+- `200+`: Transaction/Unit of Work (innermost)
+
+### Registering Custom Behaviors
+
+Add your behavior to the module providers:
+
+```typescript
+@Module({
+  imports: [
+    NestMediatorModule.forRootAsync({
+      behaviors: [MyCustomBehavior],
+    }),
+  ],
+  providers: [
+    MyCustomBehavior, // Also add to providers for DI
+  ],
+})
+export class AppModule {}
+```
+
+Or use the `@PipelineBehavior` decorator and add to providers - it will be auto-discovered:
+
+```typescript
+@Module({
+  imports: [NestMediatorModule.forRoot()],
+  providers: [MyCustomBehavior], // Auto-discovered via decorator
+})
+export class AppModule {}
+```
+
+### Skipping Behaviors for Specific Commands/Queries
+
+Use `@SkipBehavior` to exclude specific behaviors from a command or query:
+
+```typescript
+import {
+  ICommand,
+  SkipBehavior,
+  PerformanceBehavior,
+  LoggingBehavior,
+} from '@rolandsall24/nest-mediator';
+
+// Skip a single behavior
+@SkipBehavior(PerformanceBehavior)
+export class HighFrequencyCommand implements ICommand {
+  // This command will not trigger performance tracking
+}
+
+// Skip multiple behaviors
+@SkipBehavior([PerformanceBehavior, LoggingBehavior])
+export class HealthCheckQuery implements IQuery {
+  // This query skips both performance and logging behaviors
+}
+```
+
+This works with both built-in behaviors and custom behaviors:
+
+```typescript
+import { SkipBehavior } from '@rolandsall24/nest-mediator';
+import { MyAuditBehavior } from './behaviors/audit.behavior';
+
+@SkipBehavior(MyAuditBehavior)
+export class InternalCommand implements ICommand {
+  // Skips your custom audit behavior
+}
+```
+
+### Custom Behavior with Service Injection
+
+Behaviors support full NestJS dependency injection:
+
+```typescript
+import { Injectable, Logger } from '@nestjs/common';
+import { IPipelineBehavior, PipelineBehavior } from '@rolandsall24/nest-mediator';
+
+// Service for audit logging
+@Injectable()
+export class AuditService {
+  private readonly logger = new Logger(AuditService.name);
+
+  async logAction(action: string, userId: string): Promise<void> {
+    this.logger.log(`[AUDIT] ${action} by ${userId}`);
+    // Save to database, send to external service, etc.
+  }
+}
+
+// Behavior that uses the service
+@Injectable()
+@PipelineBehavior({ priority: 50, scope: 'command' })
+export class AuditLoggingBehavior<TRequest, TResponse>
+  implements IPipelineBehavior<TRequest, TResponse> {
+
+  constructor(private readonly auditService: AuditService) {}
+
+  async handle(
+    request: TRequest,
+    next: () => Promise<TResponse>,
+  ): Promise<TResponse> {
+    const requestName = request.constructor.name;
+
+    await this.auditService.logAction(`Executing ${requestName}`, 'user-123');
+
+    const response = await next();
+
+    await this.auditService.logAction(`Completed ${requestName}`, 'user-123');
+
+    return response;
+  }
+}
+
+// Register both in your module
+@Module({
+  imports: [NestMediatorModule.forRoot()],
+  providers: [
+    AuditService,           // The service
+    AuditLoggingBehavior,   // The behavior (auto-discovered)
+  ],
+})
+export class AppModule {}
+```
+
+### Advanced Behavior Examples
+
+#### Retry Behavior (for transient failures)
+
+```typescript
+@Injectable()
+@PipelineBehavior({ priority: -50, scope: 'command' })
+export class RetryBehavior<TRequest, TResponse>
+  implements IPipelineBehavior<TRequest, TResponse> {
+
+  private readonly maxRetries = 3;
+
+  async handle(
+    request: TRequest,
+    next: () => Promise<TResponse>,
+  ): Promise<TResponse> {
+    let lastError: Error;
+
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await next();
+      } catch (error) {
+        lastError = error as Error;
+
+        // Don't retry validation errors
+        if (error.name?.includes('Validation')) throw error;
+
+        if (attempt < this.maxRetries) {
+          const delay = 100 * Math.pow(2, attempt - 1); // Exponential backoff
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    throw lastError!;
+  }
+}
+```
+
+#### Caching Behavior (for queries)
+
+```typescript
+@Injectable()
+@PipelineBehavior({ priority: 5, scope: 'query' })
+export class CachingBehavior<TRequest, TResponse>
+  implements IPipelineBehavior<TRequest, TResponse> {
+
+  private cache = new Map<string, { data: any; expiry: number }>();
+
+  async handle(
+    request: TRequest,
+    next: () => Promise<TResponse>,
+  ): Promise<TResponse> {
+    const key = JSON.stringify(request);
+    const cached = this.cache.get(key);
+
+    if (cached && cached.expiry > Date.now()) {
+      return cached.data; // Cache hit
+    }
+
+    const result = await next();
+
+    this.cache.set(key, {
+      data: result,
+      expiry: Date.now() + 30000, // 30 second TTL
+    });
+
+    return result;
+  }
+}
+```
+
+#### Authorization Behavior
+
+```typescript
+@Injectable()
+@PipelineBehavior({ priority: 25, scope: 'all' })
+export class AuthorizationBehavior<TRequest, TResponse>
+  implements IPipelineBehavior<TRequest, TResponse> {
+
+  constructor(private readonly authService: AuthService) {}
+
+  private readonly adminOnlyCommands = ['DeleteUserCommand'];
+
+  async handle(
+    request: TRequest,
+    next: () => Promise<TResponse>,
+  ): Promise<TResponse> {
+    const requestName = request.constructor.name;
+
+    if (!this.authService.isAuthenticated()) {
+      throw new UnauthorizedException('Authentication required');
+    }
+
+    if (this.adminOnlyCommands.includes(requestName)) {
+      if (!this.authService.hasRole('admin')) {
+        throw new ForbiddenException('Admin role required');
+      }
+    }
+
+    return next();
+  }
+}
+```
+
+### Complete Behavior Execution Order Example
+
+With the following behaviors configured:
+
+```typescript
+// Built-in behaviors (when enabled):
+// ExceptionHandlingBehavior: priority -100, scope 'all'
+// LoggingBehavior: priority 0, scope 'all'
+// PerformanceBehavior: priority 10, scope 'all'
+// ValidationBehavior: priority 100, scope 'all'
+
+// Custom behaviors:
+// RetryBehavior: priority -50, scope 'command'
+// CachingBehavior: priority 5, scope 'query'
+// AuthorizationBehavior: priority 25, scope 'all'
+// AuditLoggingBehavior: priority 50, scope 'command'
+```
+
+**For a Command:**
+```
+Request → Exception(-100) → Retry(-50) → Logging(0) → Performance(10) → Authorization(25) → Audit(50) → Validation(100) → Handler
+```
+
+**For a Query:**
+```
+Request → Exception(-100) → Logging(0) → Caching(5) → Performance(10) → Authorization(25) → Validation(100) → Handler
+```
+
+### Validation with class-validator
+
+When `enableValidation` is true, requests are validated using class-validator (if installed):
+
+```typescript
+import { IsEmail, IsString, MinLength } from 'class-validator';
+import { ICommand } from '@rolandsall24/nest-mediator';
+
+export class CreateUserCommand implements ICommand {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(2)
+  name: string;
+
+  constructor(email: string, name: string) {
+    this.email = email;
+    this.name = name;
+  }
+}
+
+// If validation fails, ValidationException is thrown with details
+```
+
+### Pipeline Execution Order
+
+With behaviors at priorities -100, 0, 10, 100:
+
+```
+Request → ExceptionHandling(-100) → Logging(0) → Performance(10) → Validation(100) → Handler
+Response ← ExceptionHandling(-100) ← Logging(0) ← Performance(10) ← Validation(100) ← Handler
+```
+
 ## Best Practices
 
 1. **Keep Commands and Queries Simple**: They should be simple data containers with minimal logic.

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './lib/interfaces/index.js';
 export * from './lib/decorators/index.js';
 export * from './lib/services/index.js';
+export * from './lib/behaviors/index.js';
+export * from './lib/exceptions/index.js';
 export * from './lib/nest-mediator.module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,2BAA2B,CAAC;AAG1C,cAAc,2BAA2B,CAAC;AAG1C,cAAc,yBAAyB,CAAC;AAGxC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,2BAA2B,CAAC;AAG1C,cAAc,2BAA2B,CAAC;AAG1C,cAAc,yBAAyB,CAAC;AAGxC,cAAc,0BAA0B,CAAC;AAGzC,cAAc,2BAA2B,CAAC;AAG1C,cAAc,+BAA+B,CAAC"}

package/dist/index.js

@@ -20,6 +20,10 @@ __exportStar(require("./lib/interfaces/index.js"), exports);
 __exportStar(require("./lib/decorators/index.js"), exports);
 // Services
 __exportStar(require("./lib/services/index.js"), exports);
+// Behaviors
+__exportStar(require("./lib/behaviors/index.js"), exports);
+// Exceptions
+__exportStar(require("./lib/exceptions/index.js"), exports);
 // Module
 __exportStar(require("./lib/nest-mediator.module.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,aAAa;AACb,4DAA0C;AAE1C,aAAa;AACb,4DAA0C;AAE1C,WAAW;AACX,0DAAwC;AAExC,SAAS;AACT,gEAA8C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,aAAa;AACb,4DAA0C;AAE1C,aAAa;AACb,4DAA0C;AAE1C,WAAW;AACX,0DAAwC;AAExC,YAAY;AACZ,2DAAyC;AAEzC,aAAa;AACb,4DAA0C;AAE1C,SAAS;AACT,gEAA8C"}

package/dist/lib/behaviors/exception-handling.behavior.d.ts

@@ -0,0 +1,46 @@
+import { IPipelineBehavior } from '../interfaces/pipeline-behavior.interface.js';
+/**
+ * Interface for custom exception handlers.
+ * Implement this to transform or handle specific exception types.
+ */
+export interface IExceptionHandler {
+    /**
+     * Check if this handler can handle the given error
+     */
+    canHandle(error: Error): boolean;
+    /**
+     * Handle the error - can transform it, log it, or rethrow
+     */
+    handle(error: Error, request: any): Error | Promise<Error>;
+}
+/**
+ * Pipeline behavior that provides centralized exception handling.
+ * This behavior wraps all other behaviors and handlers, catching any exceptions.
+ *
+ * Priority: -100 (executes first/outermost to catch all exceptions)
+ *
+ * Features:
+ * - Catches all exceptions from the pipeline
+ * - Logs exceptions with request context
+ * - Can be extended with custom exception handlers
+ *
+ * @example
+ * ```typescript
+ * // The behavior automatically catches and logs all exceptions
+ * await mediator.send(new CreateUserCommand('invalid'));
+ * // If handler throws, ExceptionHandlingBehavior logs:
+ * // [MediatorBus] Exception in CreateUserCommand: User validation failed
+ * ```
+ */
+export declare class ExceptionHandlingBehavior<TRequest = any, TResponse = any> implements IPipelineBehavior<TRequest, TResponse> {
+    private readonly logger;
+    private readonly exceptionHandlers;
+    /**
+     * Register a custom exception handler
+     */
+    registerExceptionHandler(handler: IExceptionHandler): void;
+    handle(request: TRequest, next: () => Promise<TResponse>): Promise<TResponse>;
+    private processException;
+    private getRequestName;
+}
+//# sourceMappingURL=exception-handling.behavior.d.ts.map

package/dist/lib/behaviors/exception-handling.behavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception-handling.behavior.d.ts","sourceRoot":"","sources":["../../../src/lib/behaviors/exception-handling.behavior.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AAGjF;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAEjC;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,GAAG,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAEa,yBAAyB,CAAC,QAAQ,GAAG,GAAG,EAAE,SAAS,GAAG,GAAG,CACpE,YAAW,iBAAiB,CAAC,QAAQ,EAAE,SAAS,CAAC;IAEjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA2B;IAE7D;;OAEG;IACH,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAIpD,MAAM,CACV,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,GAC7B,OAAO,CAAC,SAAS,CAAC;YAYP,gBAAgB;IAuB9B,OAAO,CAAC,cAAc;CAMvB"}

package/dist/lib/behaviors/exception-handling.behavior.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandlingBehavior = void 0;
+const common_1 = require("@nestjs/common");
+const pipeline_behavior_decorator_js_1 = require("../decorators/pipeline-behavior.decorator.js");
+/**
+ * Pipeline behavior that provides centralized exception handling.
+ * This behavior wraps all other behaviors and handlers, catching any exceptions.
+ *
+ * Priority: -100 (executes first/outermost to catch all exceptions)
+ *
+ * Features:
+ * - Catches all exceptions from the pipeline
+ * - Logs exceptions with request context
+ * - Can be extended with custom exception handlers
+ *
+ * @example
+ * ```typescript
+ * // The behavior automatically catches and logs all exceptions
+ * await mediator.send(new CreateUserCommand('invalid'));
+ * // If handler throws, ExceptionHandlingBehavior logs:
+ * // [MediatorBus] Exception in CreateUserCommand: User validation failed
+ * ```
+ */
+let ExceptionHandlingBehavior = class ExceptionHandlingBehavior {
+    constructor() {
+        this.logger = new common_1.Logger('MediatorBus');
+        this.exceptionHandlers = [];
+    }
+    /**
+     * Register a custom exception handler
+     */
+    registerExceptionHandler(handler) {
+        this.exceptionHandlers.push(handler);
+    }
+    async handle(request, next) {
+        try {
+            return await next();
+        }
+        catch (error) {
+            const processedError = await this.processException(error, request);
+            throw processedError;
+        }
+    }
+    async processException(error, request) {
+        const requestName = this.getRequestName(request);
+        // Log the exception
+        this.logger.error(`Exception in ${requestName}: ${error.message}`, error.stack);
+        // Try custom exception handlers
+        for (const handler of this.exceptionHandlers) {
+            if (handler.canHandle(error)) {
+                return handler.handle(error, request);
+            }
+        }
+        // Return original error if no handler processed it
+        return error;
+    }
+    getRequestName(request) {
+        if (request && typeof request === 'object' && request.constructor) {
+            return request.constructor.name;
+        }
+        return 'UnknownRequest';
+    }
+};
+exports.ExceptionHandlingBehavior = ExceptionHandlingBehavior;
+exports.ExceptionHandlingBehavior = ExceptionHandlingBehavior = __decorate([
+    (0, common_1.Injectable)(),
+    (0, pipeline_behavior_decorator_js_1.PipelineBehavior)({ priority: -100, scope: 'all' })
+], ExceptionHandlingBehavior);
+//# sourceMappingURL=exception-handling.behavior.js.map