@rolandsall24/nest-mediator 0.5.2 → 0.7.0

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

package/dist/lib/decorators/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iEAA+C;AAC/C,+DAA6C;AAC7C,mEAAiD;AACjD,+DAA6C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/decorators/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iEAA+C;AAC/C,+DAA6C;AAC7C,mEAAiD;AACjD,+DAA6C;AAC7C,+DAA6C;AAC7C,mEAAiD"}

package/dist/lib/decorators/pipeline-behavior.decorator.d.ts

@@ -3,6 +3,11 @@ import { PipelineBehaviorOptions } from '../interfaces/pipeline-behavior.interfa
  * Metadata key for pipeline behavior registration
  */
 export declare const PIPELINE_BEHAVIOR_METADATA = "PIPELINE_BEHAVIOR_METADATA";
+/**
+ * Metadata key to mark that the handle method has the decorator applied
+ * (used to trigger design:paramtypes emission for type inference)
+ */
+export declare const PIPELINE_BEHAVIOR_HANDLE_METADATA = "PIPELINE_BEHAVIOR_HANDLE_METADATA";
 /**
  * Decorator that marks a class as a pipeline behavior.
  * Pipeline behaviors execute around request handlers, enabling cross-cutting concerns.
@@ -45,7 +50,51 @@ export declare const PIPELINE_BEHAVIOR_METADATA = "PIPELINE_BEHAVIOR_METADATA";
  *     return next();
  *   }
  * }
+ *
+ * // Type-specific behavior - only applies to CreateUserCommand
+ * // Use @Handle() on the method to enable automatic type inference
+ * @Injectable()
+ * @PipelineBehavior({ priority: 100, scope: 'command' })
+ * export class CreateUserValidationBehavior implements IPipelineBehavior<CreateUserCommand, any> {
+ *   @Handle()  // Enables type inference from method signature
+ *   async handle(request: CreateUserCommand, next: () => Promise<any>): Promise<any> {
+ *     // This behavior only runs for CreateUserCommand - no instanceof check needed!
+ *     await this.validate(request);
+ *     return next();
+ *   }
+ * }
  * ```
  */
 export declare const PipelineBehavior: (options?: PipelineBehaviorOptions) => ClassDecorator;
+/**
+ * Method decorator that enables automatic request type inference for pipeline behaviors.
+ *
+ * When applied to the `handle` method of a pipeline behavior, TypeScript emits
+ * `design:paramtypes` metadata that the library reads to determine which request
+ * type the behavior should apply to.
+ *
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * @PipelineBehavior({ priority: 100, scope: 'command' })
+ * export class CreateUserValidationBehavior
+ *   implements IPipelineBehavior<CreateUserCommand, void>
+ * {
+ *   @Handle()  // Enables type inference - behavior only runs for CreateUserCommand
+ *   async handle(
+ *     request: CreateUserCommand,
+ *     next: () => Promise<void>,
+ *   ): Promise<void> {
+ *     // No instanceof check needed - this only runs for CreateUserCommand
+ *     if (!request.email.includes('@')) {
+ *       throw new Error('Invalid email');
+ *     }
+ *     return next();
+ *   }
+ * }
+ * ```
+ */
+export declare const Handle: () => MethodDecorator;
 //# sourceMappingURL=pipeline-behavior.decorator.d.ts.map

package/dist/lib/decorators/pipeline-behavior.decorator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-behavior.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/pipeline-behavior.decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAEvF;;GAEG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAUvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,uBAAuB,KAChC,cAMF,CAAC"}
+{"version":3,"file":"pipeline-behavior.decorator.d.ts","sourceRoot":"","sources":["../../../src/lib/decorators/pipeline-behavior.decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAEvF;;GAEG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,iCAAiC,sCAAsC,CAAC;AAUrF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,uBAAuB,KAChC,cAMF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,MAAM,QAAO,eASzB,CAAC"}

package/dist/lib/decorators/pipeline-behavior.decorator.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PipelineBehavior = exports.PIPELINE_BEHAVIOR_METADATA = void 0;
+exports.Handle = exports.PipelineBehavior = exports.PIPELINE_BEHAVIOR_HANDLE_METADATA = exports.PIPELINE_BEHAVIOR_METADATA = void 0;
 const common_1 = require("@nestjs/common");
 /**
  * Metadata key for pipeline behavior registration
  */
 exports.PIPELINE_BEHAVIOR_METADATA = 'PIPELINE_BEHAVIOR_METADATA';
+/**
+ * Metadata key to mark that the handle method has the decorator applied
+ * (used to trigger design:paramtypes emission for type inference)
+ */
+exports.PIPELINE_BEHAVIOR_HANDLE_METADATA = 'PIPELINE_BEHAVIOR_HANDLE_METADATA';
 /**
  * Default options for pipeline behaviors
  */
@@ -55,6 +60,19 @@ const DEFAULT_OPTIONS = {
  *     return next();
  *   }
  * }
+ *
+ * // Type-specific behavior - only applies to CreateUserCommand
+ * // Use @Handle() on the method to enable automatic type inference
+ * @Injectable()
+ * @PipelineBehavior({ priority: 100, scope: 'command' })
+ * export class CreateUserValidationBehavior implements IPipelineBehavior<CreateUserCommand, any> {
+ *   @Handle()  // Enables type inference from method signature
+ *   async handle(request: CreateUserCommand, next: () => Promise<any>): Promise<any> {
+ *     // This behavior only runs for CreateUserCommand - no instanceof check needed!
+ *     await this.validate(request);
+ *     return next();
+ *   }
+ * }
  * ```
  */
 const PipelineBehavior = (options) => {
@@ -65,4 +83,41 @@ const PipelineBehavior = (options) => {
     return (0, common_1.SetMetadata)(exports.PIPELINE_BEHAVIOR_METADATA, mergedOptions);
 };
 exports.PipelineBehavior = PipelineBehavior;
+/**
+ * Method decorator that enables automatic request type inference for pipeline behaviors.
+ *
+ * When applied to the `handle` method of a pipeline behavior, TypeScript emits
+ * `design:paramtypes` metadata that the library reads to determine which request
+ * type the behavior should apply to.
+ *
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * @PipelineBehavior({ priority: 100, scope: 'command' })
+ * export class CreateUserValidationBehavior
+ *   implements IPipelineBehavior<CreateUserCommand, void>
+ * {
+ *   @Handle()  // Enables type inference - behavior only runs for CreateUserCommand
+ *   async handle(
+ *     request: CreateUserCommand,
+ *     next: () => Promise<void>,
+ *   ): Promise<void> {
+ *     // No instanceof check needed - this only runs for CreateUserCommand
+ *     if (!request.email.includes('@')) {
+ *       throw new Error('Invalid email');
+ *     }
+ *     return next();
+ *   }
+ * }
+ * ```
+ */
+const Handle = () => {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(exports.PIPELINE_BEHAVIOR_HANDLE_METADATA, true, target, propertyKey);
+        return descriptor;
+    };
+};
+exports.Handle = Handle;
 //# sourceMappingURL=pipeline-behavior.decorator.js.map

package/dist/lib/decorators/pipeline-behavior.decorator.js.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-behavior.decorator.js","sourceRoot":"","sources":["../../../src/lib/decorators/pipeline-behavior.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAG7C;;GAEG;AACU,QAAA,0BAA0B,GAAG,4BAA4B,CAAC;AAEvE;;GAEG;AACH,MAAM,eAAe,GAA4B;IAC/C,QAAQ,EAAE,CAAC;IACX,KAAK,EAAE,KAAK;CACb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACI,MAAM,gBAAgB,GAAG,CAC9B,OAAiC,EACjB,EAAE;IAClB,MAAM,aAAa,GAA4B;QAC7C,GAAG,eAAe;QAClB,GAAG,OAAO;KACX,CAAC;IACF,OAAO,IAAA,oBAAW,EAAC,kCAA0B,EAAE,aAAa,CAAC,CAAC;AAChE,CAAC,CAAC;AARW,QAAA,gBAAgB,oBAQ3B"}
+{"version":3,"file":"pipeline-behavior.decorator.js","sourceRoot":"","sources":["../../../src/lib/decorators/pipeline-behavior.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAG7C;;GAEG;AACU,QAAA,0BAA0B,GAAG,4BAA4B,CAAC;AAEvE;;;GAGG;AACU,QAAA,iCAAiC,GAAG,mCAAmC,CAAC;AAErF;;GAEG;AACH,MAAM,eAAe,GAA4B;IAC/C,QAAQ,EAAE,CAAC;IACX,KAAK,EAAE,KAAK;CACb,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,OAAiC,EACjB,EAAE;IAClB,MAAM,aAAa,GAA4B;QAC7C,GAAG,eAAe;QAClB,GAAG,OAAO;KACX,CAAC;IACF,OAAO,IAAA,oBAAW,EAAC,kCAA0B,EAAE,aAAa,CAAC,CAAC;AAChE,CAAC,CAAC;AARW,QAAA,gBAAgB,oBAQ3B;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACI,MAAM,MAAM,GAAG,GAAoB,EAAE;IAC1C,OAAO,CACL,MAAc,EACd,WAA4B,EAC5B,UAA8B,EACV,EAAE;QACtB,OAAO,CAAC,cAAc,CAAC,yCAAiC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;QACrF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,MAAM,UASjB"}

package/dist/lib/interfaces/command-bus.interface.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '@nestjs/common';
+import { ICommand } from './command.interface.js';
+import { ICommandHandler } from './command-handler.interface.js';
+/**
+ * Interface for the command bus.
+ * Responsible for dispatching commands to their handlers.
+ */
+export interface ICommandBus {
+    /**
+     * Send a command to its handler
+     * @param command - The command instance
+     */
+    send<TCommand extends ICommand>(command: TCommand): Promise<void>;
+    /**
+     * Register a command handler
+     * @param command - The command class
+     * @param handler - The handler class
+     */
+    registerCommandHandler(command: Type<ICommand>, handler: Type<ICommandHandler<any>>): void;
+    /**
+     * Get registered command names (for debugging)
+     */
+    getRegisteredCommands(): string[];
+}
+//# sourceMappingURL=command-bus.interface.d.ts.map

package/dist/lib/interfaces/command-bus.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-bus.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/interfaces/command-bus.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,IAAI,CAAC,QAAQ,SAAS,QAAQ,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE;;;;OAIG;IACH,sBAAsB,CACpB,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,EACvB,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,GAClC,IAAI,CAAC;IAER;;OAEG;IACH,qBAAqB,IAAI,MAAM,EAAE,CAAC;CACnC"}

package/dist/lib/interfaces/command-bus.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=command-bus.interface.js.map

package/dist/lib/interfaces/command-bus.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-bus.interface.js","sourceRoot":"","sources":["../../../src/lib/interfaces/command-bus.interface.ts"],"names":[],"mappings":""}

package/dist/lib/interfaces/event-bus.interface.d.ts

@@ -0,0 +1,35 @@
+import { Type } from '@nestjs/common';
+import { IEvent, EventPublishResult } from './event.interface.js';
+import { IEventConsumer } from './event-consumer.interface.js';
+import { EventCriticalityMetadata } from './event-criticality.interface.js';
+/**
+ * Interface for the event bus.
+ * Responsible for publishing events to their consumers.
+ */
+export interface IEventBus {
+    /**
+     * Publish an event to all its consumers
+     * @param event - The event instance
+     * @returns Promise with the publish result
+     */
+    publish<TEvent extends IEvent>(event: TEvent): Promise<EventPublishResult>;
+    /**
+     * Register an event consumer
+     * @param event - The event class
+     * @param handler - The consumer class
+     * @param criticalityMetadata - Criticality metadata
+     */
+    registerEventHandler(event: Type<IEvent>, handler: Type<IEventConsumer<any>>, criticalityMetadata?: EventCriticalityMetadata): void;
+    /**
+     * Get registered events and their consumers (for debugging)
+     */
+    getRegisteredEvents(): {
+        event: string;
+        handlers: {
+            name: string;
+            criticality: string;
+            order: number;
+        }[];
+    }[];
+}
+//# sourceMappingURL=event-bus.interface.d.ts.map

package/dist/lib/interfaces/event-bus.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/interfaces/event-bus.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,OAAO,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE3E;;;;;OAKG;IACH,oBAAoB,CAClB,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,EACnB,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EAClC,mBAAmB,CAAC,EAAE,wBAAwB,GAC7C,IAAI,CAAC;IAER;;OAEG;IACH,mBAAmB,IAAI;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KAClE,EAAE,CAAC;CACL"}

package/dist/lib/interfaces/event-bus.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event-bus.interface.js.map

package/dist/lib/interfaces/event-bus.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.interface.js","sourceRoot":"","sources":["../../../src/lib/interfaces/event-bus.interface.ts"],"names":[],"mappings":""}

package/dist/lib/interfaces/event-consumer.interface.d.ts

@@ -0,0 +1,64 @@
+import { IEvent } from './event.interface.js';
+/**
+ * Interface for event consumers.
+ * Event consumers subscribe to events and react to them.
+ * Multiple consumers can subscribe to the same event.
+ *
+ * Use this interface for non-critical consumers (fire-and-forget).
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(UserCreatedEvent)
+ * @NonCritical()
+ * export class SendWelcomeEmailConsumer implements IEventConsumer<UserCreatedEvent> {
+ *   async handle(event: UserCreatedEvent): Promise<void> {
+ *     await this.emailService.sendWelcome(event.userEmail);
+ *   }
+ * }
+ * ```
+ */
+export interface IEventConsumer<TEvent extends IEvent> {
+    /**
+     * Handle the event
+     * @param event - The event instance
+     */
+    handle(event: TEvent): Promise<void>;
+}
+/**
+ * Interface for critical event consumers with optional compensation.
+ * Critical consumers run sequentially and can define a compensate method
+ * that will be called if a subsequent critical consumer fails.
+ *
+ * Compensation is called in reverse order (last succeeded -> first succeeded)
+ * when a critical consumer in the chain fails.
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(OrderPlacedEvent)
+ * @Critical({ order: 2 })
+ * export class ReserveInventoryConsumer implements ICriticalEventConsumer<OrderPlacedEvent> {
+ *   async handle(event: OrderPlacedEvent): Promise<void> {
+ *     await this.inventoryService.reserve(event.orderId, event.items);
+ *   }
+ *
+ *   async compensate(event: OrderPlacedEvent): Promise<void> {
+ *     await this.inventoryService.releaseByOrderId(event.orderId);
+ *   }
+ * }
+ * ```
+ */
+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.
+     *
+     * @param event - The same event instance passed to handle()
+     */
+    compensate?(event: TEvent): Promise<void>;
+}
+/**
+ * @deprecated Use IEventConsumer instead
+ */
+export type IEventHandler<TEvent extends IEvent> = IEventConsumer<TEvent>;
+//# sourceMappingURL=event-consumer.interface.d.ts.map

package/dist/lib/interfaces/event-consumer.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-consumer.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/interfaces/event-consumer.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,cAAc,CAAC,MAAM,SAAS,MAAM;IACnD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,sBAAsB,CAAC,MAAM,SAAS,MAAM,CAAE,SAAQ,cAAc,CAAC,MAAM,CAAC;IAC3F;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,SAAS,MAAM,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC"}

package/dist/lib/interfaces/event-consumer.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event-consumer.interface.js.map

package/dist/lib/interfaces/event-consumer.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-consumer.interface.js","sourceRoot":"","sources":["../../../src/lib/interfaces/event-consumer.interface.ts"],"names":[],"mappings":""}

package/dist/lib/interfaces/event-criticality.interface.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Criticality level for event consumers.
+ * Determines how the consumer is executed when an event is published.
+ */
+export declare enum EventCriticality {
+    /**
+     * Critical consumers run sequentially in order.
+     * - Must complete before non-critical consumers start
+     * - If one fails, the publish operation fails
+     * - Are awaited by the caller
+     */
+    CRITICAL = "critical",
+    /**
+     * Non-critical consumers run in parallel after critical consumers complete.
+     * - Fire and forget (not awaited by the caller)
+     * - Failures are logged but don't affect the publish result
+     * - Don't block the caller
+     */
+    NON_CRITICAL = "non-critical"
+}
+/**
+ * Metadata stored for event consumer criticality
+ */
+export interface EventCriticalityMetadata {
+    criticality: EventCriticality;
+    order: number;
+}
+//# sourceMappingURL=event-criticality.interface.d.ts.map

package/dist/lib/interfaces/event-criticality.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-criticality.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/interfaces/event-criticality.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B;;;;;OAKG;IACH,QAAQ,aAAa;IAErB;;;;;OAKG;IACH,YAAY,iBAAiB;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,gBAAgB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/lib/interfaces/event-criticality.interface.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCriticality = void 0;
+/**
+ * Criticality level for event consumers.
+ * Determines how the consumer is executed when an event is published.
+ */
+var EventCriticality;
+(function (EventCriticality) {
+    /**
+     * Critical consumers run sequentially in order.
+     * - Must complete before non-critical consumers start
+     * - If one fails, the publish operation fails
+     * - Are awaited by the caller
+     */
+    EventCriticality["CRITICAL"] = "critical";
+    /**
+     * Non-critical consumers run in parallel after critical consumers complete.
+     * - Fire and forget (not awaited by the caller)
+     * - Failures are logged but don't affect the publish result
+     * - Don't block the caller
+     */
+    EventCriticality["NON_CRITICAL"] = "non-critical";
+})(EventCriticality || (exports.EventCriticality = EventCriticality = {}));
+//# sourceMappingURL=event-criticality.interface.js.map

package/dist/lib/interfaces/event-criticality.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-criticality.interface.js","sourceRoot":"","sources":["../../../src/lib/interfaces/event-criticality.interface.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,IAAY,gBAgBX;AAhBD,WAAY,gBAAgB;IAC1B;;;;;OAKG;IACH,yCAAqB,CAAA;IAErB;;;;;OAKG;IACH,iDAA6B,CAAA;AAC/B,CAAC,EAhBW,gBAAgB,gCAAhB,gBAAgB,QAgB3B"}

package/dist/lib/interfaces/event-handler.interface.d.ts

@@ -0,0 +1,24 @@
+import { IEvent } from './event.interface.js';
+/**
+ * Interface for event handlers
+ * Event handlers subscribe to events and react to them.
+ * Multiple handlers can subscribe to the same event.
+ *
+ * @example
+ * ```typescript
+ * @EventHandler(UserCreatedEvent)
+ * export class SendWelcomeEmailHandler implements IEventHandler<UserCreatedEvent> {
+ *   async handle(event: UserCreatedEvent): Promise<void> {
+ *     await this.emailService.sendWelcome(event.userEmail);
+ *   }
+ * }
+ * ```
+ */
+export interface IEventHandler<TEvent extends IEvent> {
+    /**
+     * Handle the event
+     * @param event - The event instance
+     */
+    handle(event: TEvent): Promise<void>;
+}
+//# sourceMappingURL=event-handler.interface.d.ts.map

package/dist/lib/interfaces/event-handler.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/interfaces/event-handler.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAa,CAAC,MAAM,SAAS,MAAM;IAClD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC"}

package/dist/lib/interfaces/event-handler.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event-handler.interface.js.map

package/dist/lib/interfaces/event-handler.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.interface.js","sourceRoot":"","sources":["../../../src/lib/interfaces/event-handler.interface.ts"],"names":[],"mappings":""}