@nestjs/cqrs 9.0.4 → 10.0.1

package/.circleci/config.yml

@@ -3,21 +3,21 @@ version: 2
 aliases:
   - &restore-cache
     restore_cache:
-        key: dependency-cache-{{ checksum "package.json" }}
+      key: dependency-cache-{{ checksum "package.json" }}
   - &install-deps
     run:
-        name: Install dependencies
-        command: npm ci
+      name: Install dependencies
+      command: npm ci --ignore-scripts
   - &build-packages
     run:
-        name: Build
-        command: npm run build
+      name: Build
+      command: npm run build
 
 jobs:
   build:
     working_directory: ~/nest
     docker:
-      - image: cimg/node:19.6
+      - image: cimg/node:20.3
     steps:
       - checkout
       - run:
@@ -27,18 +27,17 @@ jobs:
           key: dependency-cache-{{ checksum "package.json" }}
       - run:
           name: Install dependencies
-          command: npm ci
+          command: npm ci --ignore-scripts
       - save_cache:
           key: dependency-cache-{{ checksum "package.json" }}
           paths:
             - ./node_modules
       - run:
           name: Build
-          command: npm run build    
+          command: npm run build
 
 workflows:
   version: 2
   build-and-test:
     jobs:
       - build
-      

package/dist/aggregate-root.d.ts

@@ -1,18 +1,63 @@
-import { IEvent, IEventHandler } from './interfaces';
 import { Type } from '@nestjs/common';
+import { IEvent, IEventHandler } from './interfaces';
 declare const INTERNAL_EVENTS: unique symbol;
 declare const IS_AUTO_COMMIT_ENABLED: unique symbol;
+/**
+ * Represents an aggregate root.
+ * An aggregate root is an entity that represents a meaningful concept in the domain.
+ * It is the root of an aggregate, which is a cluster of domain objects that can be treated as a single unit.
+ *
+ * @template EventBase The base type of the events.
+ */
 export declare abstract class AggregateRoot<EventBase extends IEvent = IEvent> {
     [IS_AUTO_COMMIT_ENABLED]: boolean;
     private readonly [INTERNAL_EVENTS];
+    /**
+     * Sets whether the aggregate root should automatically commit events.
+     */
     set autoCommit(value: boolean);
+    /**
+     * Gets whether the aggregate root should automatically commit events.
+     */
     get autoCommit(): boolean;
+    /**
+     * Publishes an event. Must be merged with the publisher context in order to work.
+     * @param event The event to publish.
+     */
     publish<T extends EventBase = EventBase>(event: T): void;
-    publishAll<T extends EventBase = EventBase>(event: T[]): void;
+    /**
+     * Publishes multiple events. Must be merged with the publisher context in order to work.
+     * @param events The events to publish.
+     */
+    publishAll<T extends EventBase = EventBase>(events: T[]): void;
+    /**
+     * Commits all uncommitted events.
+     */
     commit(): void;
+    /**
+     * Uncommits all events.
+     */
     uncommit(): void;
+    /**
+     * Returns all uncommitted events.
+     * @returns All uncommitted events.
+     */
     getUncommittedEvents(): EventBase[];
+    /**
+     * Loads events from history.
+     * @param history The history to load.
+     */
     loadFromHistory(history: EventBase[]): void;
+    /**
+     * Applies an event.
+     * If auto commit is enabled, the event will be published immediately (note: must be merged with the publisher context in order to work).
+     * Otherwise, the event will be stored in the internal events array, and will be published when the commit method is called.
+     * Also, the corresponding event handler will be called (if exists).
+     * For example, if the event is called UserCreatedEvent, the "onUserCreatedEvent" method will be called.
+     *
+     * @param event The event to apply.
+     * @param isFromHistory Whether the event is from history.
+     */
     apply<T extends EventBase = EventBase>(event: T, isFromHistory?: boolean): void;
     protected getEventHandler<T extends EventBase = EventBase>(event: T): Type<IEventHandler> | undefined;
     protected getEventName(event: any): string;

package/dist/aggregate-root.js

@@ -4,32 +4,77 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateRoot = void 0;
 const INTERNAL_EVENTS = Symbol();
 const IS_AUTO_COMMIT_ENABLED = Symbol();
+/**
+ * Represents an aggregate root.
+ * An aggregate root is an entity that represents a meaningful concept in the domain.
+ * It is the root of an aggregate, which is a cluster of domain objects that can be treated as a single unit.
+ *
+ * @template EventBase The base type of the events.
+ */
 class AggregateRoot {
     constructor() {
         this[_a] = false;
         this[_b] = [];
     }
+    /**
+     * Sets whether the aggregate root should automatically commit events.
+     */
     set autoCommit(value) {
         this[IS_AUTO_COMMIT_ENABLED] = value;
     }
+    /**
+     * Gets whether the aggregate root should automatically commit events.
+     */
     get autoCommit() {
         return this[IS_AUTO_COMMIT_ENABLED];
     }
+    /**
+     * Publishes an event. Must be merged with the publisher context in order to work.
+     * @param event The event to publish.
+     */
     publish(event) { }
-    publishAll(event) { }
+    /**
+     * Publishes multiple events. Must be merged with the publisher context in order to work.
+     * @param events The events to publish.
+     */
+    publishAll(events) { }
+    /**
+     * Commits all uncommitted events.
+     */
     commit() {
         this.publishAll(this[INTERNAL_EVENTS]);
         this[INTERNAL_EVENTS].length = 0;
     }
+    /**
+     * Uncommits all events.
+     */
     uncommit() {
         this[INTERNAL_EVENTS].length = 0;
     }
+    /**
+     * Returns all uncommitted events.
+     * @returns All uncommitted events.
+     */
     getUncommittedEvents() {
         return this[INTERNAL_EVENTS];
     }
+    /**
+     * Loads events from history.
+     * @param history The history to load.
+     */
     loadFromHistory(history) {
         history.forEach((event) => this.apply(event, true));
     }
+    /**
+     * Applies an event.
+     * If auto commit is enabled, the event will be published immediately (note: must be merged with the publisher context in order to work).
+     * Otherwise, the event will be stored in the internal events array, and will be published when the commit method is called.
+     * Also, the corresponding event handler will be called (if exists).
+     * For example, if the event is called UserCreatedEvent, the "onUserCreatedEvent" method will be called.
+     *
+     * @param event The event to apply.
+     * @param isFromHistory Whether the event is from history.
+     */
     apply(event, isFromHistory = false) {
         if (!isFromHistory && !this.autoCommit) {
             this[INTERNAL_EVENTS].push(event);

package/dist/command-bus.d.ts

@@ -9,8 +9,22 @@ export declare class CommandBus<CommandBase extends ICommand = ICommand> extends
     private handlers;
     private _publisher;
     constructor(moduleRef: ModuleRef);
+    /**
+     * Returns the publisher.
+     * Default publisher is `DefaultCommandPubSub` (in memory).
+     */
     get publisher(): ICommandPublisher<CommandBase>;
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultCommandPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher: ICommandPublisher<CommandBase>);
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     * @returns A promise that, when resolved, will contain the result returned by the command's handler.
+     */
     execute<T extends CommandBase, R = any>(command: T): Promise<R>;
     bind<T extends CommandBase>(handler: ICommandHandler<T>, id: string): void;
     register(handlers?: CommandHandlerType[]): void;

package/dist/command-bus.js

@@ -25,12 +25,26 @@ let CommandBus = class CommandBus extends observable_bus_1.ObservableBus {
         this.handlers = new Map();
         this.useDefaultPublisher();
     }
+    /**
+     * Returns the publisher.
+     * Default publisher is `DefaultCommandPubSub` (in memory).
+     */
     get publisher() {
         return this._publisher;
     }
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultCommandPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher) {
         this._publisher = _publisher;
     }
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     * @returns A promise that, when resolved, will contain the result returned by the command's handler.
+     */
     execute(command) {
         const commandId = this.getCommandId(command);
         const handler = this.handlers.get(commandId);

package/dist/cqrs.module.d.ts

@@ -6,9 +6,9 @@ import { QueryBus } from './query-bus';
 import { ExplorerService } from './services/explorer.service';
 export declare class CqrsModule<EventBase extends IEvent = IEvent> implements OnApplicationBootstrap {
     private readonly explorerService;
-    private readonly eventsBus;
-    private readonly commandsBus;
+    private readonly eventBus;
+    private readonly commandBus;
     private readonly queryBus;
-    constructor(explorerService: ExplorerService<EventBase>, eventsBus: EventBus<EventBase>, commandsBus: CommandBus, queryBus: QueryBus);
+    constructor(explorerService: ExplorerService<EventBase>, eventBus: EventBus<EventBase>, commandBus: CommandBus, queryBus: QueryBus);
     onApplicationBootstrap(): void;
 }

package/dist/cqrs.module.js

@@ -16,25 +16,39 @@ const event_bus_1 = require("./event-bus");
 const event_publisher_1 = require("./event-publisher");
 const query_bus_1 = require("./query-bus");
 const explorer_service_1 = require("./services/explorer.service");
+const unhandled_exception_bus_1 = require("./unhandled-exception-bus");
 let CqrsModule = class CqrsModule {
-    constructor(explorerService, eventsBus, commandsBus, queryBus) {
+    constructor(explorerService, eventBus, commandBus, queryBus) {
         this.explorerService = explorerService;
-        this.eventsBus = eventsBus;
-        this.commandsBus = commandsBus;
+        this.eventBus = eventBus;
+        this.commandBus = commandBus;
         this.queryBus = queryBus;
     }
     onApplicationBootstrap() {
         const { events, queries, sagas, commands } = this.explorerService.explore();
-        this.eventsBus.register(events);
-        this.commandsBus.register(commands);
+        this.eventBus.register(events);
+        this.commandBus.register(commands);
         this.queryBus.register(queries);
-        this.eventsBus.registerSagas(sagas);
+        this.eventBus.registerSagas(sagas);
     }
 };
 CqrsModule = __decorate([
     (0, common_1.Module)({
-        providers: [command_bus_1.CommandBus, query_bus_1.QueryBus, event_bus_1.EventBus, event_publisher_1.EventPublisher, explorer_service_1.ExplorerService],
-        exports: [command_bus_1.CommandBus, query_bus_1.QueryBus, event_bus_1.EventBus, event_publisher_1.EventPublisher],
+        providers: [
+            command_bus_1.CommandBus,
+            query_bus_1.QueryBus,
+            event_bus_1.EventBus,
+            unhandled_exception_bus_1.UnhandledExceptionBus,
+            event_publisher_1.EventPublisher,
+            explorer_service_1.ExplorerService,
+        ],
+        exports: [
+            command_bus_1.CommandBus,
+            query_bus_1.QueryBus,
+            event_bus_1.EventBus,
+            unhandled_exception_bus_1.UnhandledExceptionBus,
+            event_publisher_1.EventPublisher,
+        ],
     }),
     __metadata("design:paramtypes", [explorer_service_1.ExplorerService,
         event_bus_1.EventBus,

package/dist/event-bus.d.ts

@@ -3,20 +3,39 @@ import { ModuleRef } from '@nestjs/core';
 import { Observable, Subscription } from 'rxjs';
 import { CommandBus } from './command-bus';
 import { IEvent, IEventBus, IEventHandler, IEventPublisher, ISaga } from './interfaces';
+import { UnhandledExceptionBus } from './unhandled-exception-bus';
 import { ObservableBus } from './utils';
 export declare type EventHandlerType<EventBase extends IEvent = IEvent> = Type<IEventHandler<EventBase>>;
 export declare class EventBus<EventBase extends IEvent = IEvent> extends ObservableBus<EventBase> implements IEventBus<EventBase>, OnModuleDestroy {
     private readonly commandBus;
     private readonly moduleRef;
+    private readonly unhandledExceptionBus;
     protected getEventId: (event: EventBase) => string | null;
     protected readonly subscriptions: Subscription[];
     private _publisher;
     private readonly _logger;
-    constructor(commandBus: CommandBus, moduleRef: ModuleRef);
+    constructor(commandBus: CommandBus, moduleRef: ModuleRef, unhandledExceptionBus: UnhandledExceptionBus);
+    /**
+     * Returns the publisher.
+     * Default publisher is `DefaultPubSub` (in memory).
+     */
     get publisher(): IEventPublisher<EventBase>;
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher: IEventPublisher<EventBase>);
     onModuleDestroy(): void;
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     */
     publish<T extends EventBase>(event: T): any;
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     */
     publishAll<T extends EventBase>(events: T[]): any;
     bind(handler: IEventHandler<EventBase>, id: string): void;
     registerSagas(types?: Type<unknown>[]): void;
@@ -26,4 +45,6 @@ export declare class EventBus<EventBase extends IEvent = IEvent> extends Observa
     protected registerSaga(saga: ISaga<EventBase>): void;
     private reflectEvents;
     private useDefaultPublisher;
+    private mapToUnhandledErrorInfo;
+    private isUnhandledErrorInfo;
 }

package/dist/event-bus.js

@@ -15,35 +15,53 @@ const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const util_1 = require("util");
 const command_bus_1 = require("./command-bus");
 const constants_1 = require("./decorators/constants");
 const exceptions_1 = require("./exceptions");
 const default_get_event_id_1 = require("./helpers/default-get-event-id");
 const default_pubsub_1 = require("./helpers/default-pubsub");
+const unhandled_exception_bus_1 = require("./unhandled-exception-bus");
 const utils_1 = require("./utils");
 let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
-    constructor(commandBus, moduleRef) {
+    constructor(commandBus, moduleRef, unhandledExceptionBus) {
         super();
         this.commandBus = commandBus;
         this.moduleRef = moduleRef;
+        this.unhandledExceptionBus = unhandledExceptionBus;
         this._logger = new common_1.Logger(EventBus_1.name);
         this.subscriptions = [];
         this.getEventId = default_get_event_id_1.defaultGetEventId;
         this.useDefaultPublisher();
     }
+    /**
+     * Returns the publisher.
+     * Default publisher is `DefaultPubSub` (in memory).
+     */
     get publisher() {
         return this._publisher;
     }
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher) {
         this._publisher = _publisher;
     }
     onModuleDestroy() {
         this.subscriptions.forEach((subscription) => subscription.unsubscribe());
     }
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     */
     publish(event) {
         return this._publisher.publish(event);
     }
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     */
     publishAll(events) {
         if (this._publisher.publishAll) {
             return this._publisher.publishAll(events);
@@ -53,11 +71,14 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
     bind(handler, id) {
         const stream$ = id ? this.ofEventId(id) : this.subject$;
         const subscription = stream$
-            .pipe((0, operators_1.mergeMap)((event) => (0, rxjs_1.from)(Promise.resolve(handler.handle(event)))))
+            .pipe((0, operators_1.mergeMap)((event) => (0, rxjs_1.defer)(() => Promise.resolve(handler.handle(event))).pipe((0, operators_1.catchError)((error) => (0, rxjs_1.throwError)(() => this.mapToUnhandledErrorInfo(event, error))))))
             .subscribe({
             error: (error) => {
-                this._logger.error(`"${handler.constructor.name}" has thrown an error.`, error);
-                throw error;
+                if (this.isUnhandledErrorInfo(error)) {
+                    this.unhandledExceptionBus.publish(error);
+                    error = error.exception;
+                }
+                this._logger.error(`"${handler.constructor.name}" has thrown an unhandled exception.`, error);
             },
         });
         this.subscriptions.push(subscription);
@@ -90,7 +111,7 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
         return this.subject$.pipe((0, operators_1.filter)((event) => this.getEventId(event) === id));
     }
     registerSaga(saga) {
-        if (!(0, util_1.isFunction)(saga)) {
+        if (typeof saga !== 'function') {
             throw new exceptions_1.InvalidSagaException();
         }
         const stream$ = saga(this);
@@ -98,11 +119,14 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
             throw new exceptions_1.InvalidSagaException();
         }
         const subscription = stream$
-            .pipe((0, operators_1.filter)((e) => !!e), (0, operators_1.mergeMap)((command) => (0, rxjs_1.from)(this.commandBus.execute(command))))
+            .pipe((0, operators_1.filter)((e) => !!e), (0, operators_1.mergeMap)((command) => (0, rxjs_1.defer)(() => this.commandBus.execute(command)).pipe((0, operators_1.catchError)((error) => (0, rxjs_1.throwError)(() => this.mapToUnhandledErrorInfo(command, error))))))
             .subscribe({
             error: (error) => {
-                this._logger.error(`Command handler which execution was triggered by Saga has thrown an error.`, error);
-                throw error;
+                if (this.isUnhandledErrorInfo(error)) {
+                    this.unhandledExceptionBus.publish(error);
+                    error = error.exception;
+                }
+                this._logger.error(`Command handler which execution was triggered by Saga has thrown an unhandled exception.`, error);
             },
         });
         this.subscriptions.push(subscription);
@@ -113,10 +137,23 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
     useDefaultPublisher() {
         this._publisher = new default_pubsub_1.DefaultPubSub(this.subject$);
     }
+    mapToUnhandledErrorInfo(eventOrCommand, exception) {
+        return {
+            cause: eventOrCommand,
+            exception,
+        };
+    }
+    isUnhandledErrorInfo(error) {
+        return (typeof error === 'object' &&
+            error !== null &&
+            'cause' in error &&
+            'exception' in error);
+    }
 };
 EventBus = EventBus_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [command_bus_1.CommandBus,
-        core_1.ModuleRef])
+        core_1.ModuleRef,
+        unhandled_exception_bus_1.UnhandledExceptionBus])
 ], EventBus);
 exports.EventBus = EventBus;

package/dist/event-publisher.d.ts

@@ -1,5 +1,5 @@
-import { EventBus } from './event-bus';
 import { AggregateRoot } from './aggregate-root';
+import { EventBus } from './event-bus';
 import { IEvent } from './interfaces';
 export interface Constructor<T> {
     new (...args: any[]): T;
@@ -7,6 +7,16 @@ export interface Constructor<T> {
 export declare class EventPublisher<EventBase extends IEvent = IEvent> {
     private readonly eventBus;
     constructor(eventBus: EventBus<EventBase>);
+    /**
+     * Merge the event publisher into the provided class.
+     * This is required to make `publish` and `publishAll` available on the `AgreggateRoot` class.
+     * @param metatype The class to merge into.
+     */
     mergeClassContext<T extends Constructor<AggregateRoot<EventBase>>>(metatype: T): T;
+    /**
+     * Merge the event publisher into the provided object.
+     * This is required to make `publish` and `publishAll` available on the `AgreggateRoot` class instance.
+     * @param object The object to merge into.
+     */
     mergeObjectContext<T extends AggregateRoot<EventBase>>(object: T): T;
 }

package/dist/event-publisher.js

@@ -16,6 +16,11 @@ let EventPublisher = class EventPublisher {
     constructor(eventBus) {
         this.eventBus = eventBus;
     }
+    /**
+     * Merge the event publisher into the provided class.
+     * This is required to make `publish` and `publishAll` available on the `AgreggateRoot` class.
+     * @param metatype The class to merge into.
+     */
     mergeClassContext(metatype) {
         const eventBus = this.eventBus;
         return class extends metatype {
@@ -27,6 +32,11 @@ let EventPublisher = class EventPublisher {
             }
         };
     }
+    /**
+     * Merge the event publisher into the provided object.
+     * This is required to make `publish` and `publishAll` available on the `AgreggateRoot` class instance.
+     * @param object The object to merge into.
+     */
     mergeObjectContext(object) {
         const eventBus = this.eventBus;
         object.publish = (event) => {

package/dist/helpers/default-get-event-id.js

@@ -8,9 +8,8 @@ const constants_1 = require("../decorators/constants");
  * @returns
  */
 const defaultGetEventId = (event) => {
-    var _a, _b;
     const { constructor } = Object.getPrototypeOf(event);
-    return (_b = (_a = Reflect.getMetadata(constants_1.EVENT_METADATA, constructor)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
+    return Reflect.getMetadata(constants_1.EVENT_METADATA, constructor)?.id ?? null;
 };
 exports.defaultGetEventId = defaultGetEventId;
 const defaultReflectEventId = (event) => {

package/dist/helpers/default-unhandled-exception-pubsub.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from 'rxjs';
+import { ICommand, IEvent, IUnhandledExceptionPublisher, UnhandledExceptionInfo } from '../interfaces';
+/**
+ * Default implementation of the `IUnhandledExceptionPublisher` interface.
+ */
+export declare class DefaultUnhandledExceptionPubSub<Cause = IEvent | ICommand> implements IUnhandledExceptionPublisher<Cause> {
+    private subject$;
+    constructor(subject$: Subject<UnhandledExceptionInfo<Cause>>);
+    publish(info: UnhandledExceptionInfo<Cause>): void;
+}

package/dist/helpers/default-unhandled-exception-pubsub.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultUnhandledExceptionPubSub = void 0;
+/**
+ * Default implementation of the `IUnhandledExceptionPublisher` interface.
+ */
+class DefaultUnhandledExceptionPubSub {
+    constructor(subject$) {
+        this.subject$ = subject$;
+    }
+    publish(info) {
+        this.subject$.next(info);
+    }
+}
+exports.DefaultUnhandledExceptionPubSub = DefaultUnhandledExceptionPubSub;

package/dist/index.d.ts

@@ -8,4 +8,5 @@ export * from './exceptions';
 export * from './interfaces';
 export * from './operators';
 export * from './query-bus';
+export * from './unhandled-exception-bus';
 export * from './utils';

package/dist/index.js

@@ -26,4 +26,5 @@ __exportStar(require("./exceptions"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./operators"), exports);
 __exportStar(require("./query-bus"), exports);
+__exportStar(require("./unhandled-exception-bus"), exports);
 __exportStar(require("./utils"), exports);

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

@@ -1,4 +1,11 @@
 import { ICommand } from './command.interface';
+/**
+ * Represents a command bus.
+ */
 export interface ICommandBus<CommandBase extends ICommand = ICommand> {
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     */
     execute<T extends CommandBase, R = any>(command: T): Promise<R>;
 }

package/dist/interfaces/commands/command-handler.interface.d.ts

@@ -1,4 +1,12 @@
 import { ICommand } from './command.interface';
+/**
+ * Represents a command handler.
+ * Command handlers are used to execute commands.
+ */
 export interface ICommandHandler<TCommand extends ICommand = any, TResult = any> {
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     */
     execute(command: TCommand): Promise<TResult>;
 }

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

@@ -1,5 +1,16 @@
 import { IEvent } from './event.interface';
+/**
+ * Represents an event bus.
+ */
 export interface IEventBus<EventBase extends IEvent = IEvent> {
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     */
     publish<T extends EventBase>(event: T): any;
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     */
     publishAll(events: EventBase[]): any;
 }

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

@@ -1,4 +1,11 @@
 import { IEvent } from './event.interface';
+/**
+ * Represents an event handler.
+ */
 export interface IEventHandler<T extends IEvent = any> {
+    /**
+     * Handles an event.
+     * @param event The event to handle.
+     */
     handle(event: T): any;
 }

package/dist/interfaces/exceptions/unhandled-exception-info.interface.d.ts

@@ -0,0 +1,15 @@
+import { ICommand } from '../commands/command.interface';
+import { IEvent } from '../events/event.interface';
+/**
+ * Represents an unhandled exception.
+ */
+export interface UnhandledExceptionInfo<Cause = IEvent | ICommand, Exception = any> {
+    /**
+     * The exception that was thrown.
+     */
+    exception: Exception;
+    /**
+     * The cause of the exception (event or command reference).
+     */
+    cause: Cause;
+}

package/dist/interfaces/exceptions/unhandled-exception-info.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/exceptions/unhandled-exception-publisher.interface.d.ts

@@ -0,0 +1,10 @@
+import { ICommand } from '../commands/command.interface';
+import { IEvent } from '../events/event.interface';
+import { UnhandledExceptionInfo } from './unhandled-exception-info.interface';
+export interface IUnhandledExceptionPublisher<CauseBase = IEvent | ICommand, ExceptionBase = any> {
+    /**
+     * Publishes an unhandled exception.
+     * @param info The exception information.
+     */
+    publish(info: UnhandledExceptionInfo<CauseBase, ExceptionBase>): any;
+}

package/dist/interfaces/exceptions/unhandled-exception-publisher.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -7,6 +7,8 @@ export * from './events/event-handler.interface';
 export * from './events/event-publisher.interface';
 export * from './events/event.interface';
 export * from './events/message-source.interface';
+export * from './exceptions/unhandled-exception-info.interface';
+export * from './exceptions/unhandled-exception-publisher.interface';
 export * from './queries/query-bus.interface';
 export * from './queries/query-handler.interface';
 export * from './queries/query-publisher.interface';

package/dist/interfaces/index.js

@@ -19,6 +19,8 @@ __exportStar(require("./events/event-handler.interface"), exports);
 __exportStar(require("./events/event-publisher.interface"), exports);
 __exportStar(require("./events/event.interface"), exports);
 __exportStar(require("./events/message-source.interface"), exports);
+__exportStar(require("./exceptions/unhandled-exception-info.interface"), exports);
+__exportStar(require("./exceptions/unhandled-exception-publisher.interface"), exports);
 __exportStar(require("./queries/query-bus.interface"), exports);
 __exportStar(require("./queries/query-handler.interface"), exports);
 __exportStar(require("./queries/query-publisher.interface"), exports);

package/dist/interfaces/queries/query-bus.interface.d.ts

@@ -1,4 +1,11 @@
 import { IQuery } from './query.interface';
+/**
+ * Represents a query bus.
+ */
 export interface IQueryBus<QueryBase extends IQuery = IQuery> {
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
     execute<T extends QueryBase = QueryBase, TRes = any>(query: T): Promise<TRes>;
 }

package/dist/interfaces/queries/query-handler.interface.d.ts

@@ -1,4 +1,11 @@
 import { IQuery } from './query.interface';
+/**
+ * Represents a query handler.
+ */
 export interface IQueryHandler<T extends IQuery = any, TRes = any> {
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
     execute(query: T): Promise<TRes>;
 }

package/dist/query-bus.d.ts

@@ -9,8 +9,20 @@ export declare class QueryBus<QueryBase extends IQuery = IQuery> extends Observa
     private handlers;
     private _publisher;
     constructor(moduleRef: ModuleRef);
+    /**
+     * Returns the publisher.
+     */
     get publisher(): IQueryPublisher<QueryBase>;
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultQueryPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher: IQueryPublisher<QueryBase>);
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
     execute<T extends QueryBase, TResult = any>(query: T): Promise<TResult>;
     bind<T extends QueryBase, TResult = any>(handler: IQueryHandler<T, TResult>, queryId: string): void;
     register(handlers?: QueryHandlerType<QueryBase>[]): void;

package/dist/query-bus.js

@@ -8,15 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBus = void 0;
 const common_1 = require("@nestjs/common");
@@ -34,23 +25,33 @@ let QueryBus = class QueryBus extends observable_bus_1.ObservableBus {
         this.handlers = new Map();
         this.useDefaultPublisher();
     }
+    /**
+     * Returns the publisher.
+     */
     get publisher() {
         return this._publisher;
     }
+    /**
+     * Sets the publisher.
+     * Default publisher is `DefaultQueryPubSub` (in memory).
+     * @param _publisher The publisher to set.
+     */
     set publisher(_publisher) {
         this._publisher = _publisher;
     }
-    execute(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queryId = this.getQueryId(query);
-            const handler = this.handlers.get(queryId);
-            if (!handler) {
-                throw new exceptions_1.QueryHandlerNotFoundException(queryId);
-            }
-            this._publisher.publish(query);
-            const result = yield handler.execute(query);
-            return result;
-        });
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    async execute(query) {
+        const queryId = this.getQueryId(query);
+        const handler = this.handlers.get(queryId);
+        if (!handler) {
+            throw new exceptions_1.QueryHandlerNotFoundException(queryId);
+        }
+        this._publisher.publish(query);
+        const result = await handler.execute(query);
+        return result;
     }
     bind(handler, queryId) {
         this.handlers.set(queryId, handler);

package/dist/unhandled-exception-bus.d.ts

@@ -0,0 +1,35 @@
+import { Type } from '@nestjs/common';
+import 'reflect-metadata';
+import { Observable } from 'rxjs';
+import { ICommand, IEvent, IUnhandledExceptionPublisher, UnhandledExceptionInfo } from './interfaces';
+import { ObservableBus } from './utils/observable-bus';
+/**
+ * A bus that publishes unhandled exceptions.
+ * @template Cause The type of the cause of the exception.
+ */
+export declare class UnhandledExceptionBus<Cause = IEvent | ICommand> extends ObservableBus<UnhandledExceptionInfo<Cause>> {
+    private _publisher;
+    constructor();
+    /**
+     * Filter values depending on their instance type (comparison is made
+     * using native `instanceof`).
+     *
+     * @param types List of types to filter by.
+     * @return A stream only emitting the filtered exceptions.
+     */
+    static ofType<TInput, TOutput>(...types: Type<TOutput>[]): (source: Observable<UnhandledExceptionInfo<TInput>>) => Observable<UnhandledExceptionInfo<TOutput>>;
+    /**
+     * Gets the publisher of the bus.
+     */
+    get publisher(): IUnhandledExceptionPublisher<Cause>;
+    /**
+     * Sets the publisher of the bus.
+     */
+    set publisher(_publisher: IUnhandledExceptionPublisher<Cause>);
+    /**
+     * Publishes an unhandled exception.
+     * @param info The exception information.
+     */
+    publish(info: UnhandledExceptionInfo<Cause>): any;
+    private useDefaultPublisher;
+}

package/dist/unhandled-exception-bus.js

@@ -0,0 +1,65 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnhandledExceptionBus = void 0;
+const common_1 = require("@nestjs/common");
+require("reflect-metadata");
+const rxjs_1 = require("rxjs");
+const default_unhandled_exception_pubsub_1 = require("./helpers/default-unhandled-exception-pubsub");
+const observable_bus_1 = require("./utils/observable-bus");
+/**
+ * A bus that publishes unhandled exceptions.
+ * @template Cause The type of the cause of the exception.
+ */
+let UnhandledExceptionBus = class UnhandledExceptionBus extends observable_bus_1.ObservableBus {
+    constructor() {
+        super();
+        this.useDefaultPublisher();
+    }
+    /**
+     * Filter values depending on their instance type (comparison is made
+     * using native `instanceof`).
+     *
+     * @param types List of types to filter by.
+     * @return A stream only emitting the filtered exceptions.
+     */
+    static ofType(...types) {
+        const isInstanceOf = (exceptionInfo) => !!types.find((classType) => exceptionInfo.exception instanceof classType);
+        return (source) => source.pipe((0, rxjs_1.filter)(isInstanceOf));
+    }
+    /**
+     * Gets the publisher of the bus.
+     */
+    get publisher() {
+        return this._publisher;
+    }
+    /**
+     * Sets the publisher of the bus.
+     */
+    set publisher(_publisher) {
+        this._publisher = _publisher;
+    }
+    /**
+     * Publishes an unhandled exception.
+     * @param info The exception information.
+     */
+    publish(info) {
+        return this._publisher.publish(info);
+    }
+    useDefaultPublisher() {
+        this._publisher = new default_unhandled_exception_pubsub_1.DefaultUnhandledExceptionPubSub(this.subject$);
+    }
+};
+UnhandledExceptionBus = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], UnhandledExceptionBus);
+exports.UnhandledExceptionBus = UnhandledExceptionBus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/cqrs",
-  "version": "9.0.4",
+  "version": "10.0.1",
   "description": "A lightweight CQRS module for Nest framework (node.js)",
   "license": "MIT",
   "url": "https://github.com/nestjs/cqrs#readme",
@@ -21,15 +21,15 @@
     "uuid": "9.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "17.6.3",
-    "@commitlint/config-angular": "17.6.3",
-    "@nestjs/common": "9.4.1",
-    "@nestjs/core": "9.4.1",
-    "@types/node": "18.16.12",
-    "@types/jest": "29.5.1",
-    "@typescript-eslint/eslint-plugin": "5.59.6",
-    "@typescript-eslint/parser": "5.59.6",
-    "eslint": "8.40.0",
+    "@commitlint/cli": "17.6.5",
+    "@commitlint/config-angular": "17.6.5",
+    "@nestjs/common": "10.0.3",
+    "@nestjs/core": "10.0.3",
+    "@types/node": "18.16.18",
+    "@types/jest": "29.5.2",
+    "@typescript-eslint/eslint-plugin": "5.60.0",
+    "@typescript-eslint/parser": "5.60.0",
+    "eslint": "8.43.0",
     "eslint-config-prettier": "8.8.0",
     "eslint-plugin-import": "2.27.5",
     "husky": "8.0.3",
@@ -37,14 +37,14 @@
     "lint-staged": "13.2.2",
     "prettier": "2.8.8",
     "reflect-metadata": "0.1.13",
-    "release-it": "15.10.3",
+    "release-it": "15.11.0",
     "rxjs": "7.8.1",
     "ts-jest": "29.1.0",
-    "typescript": "5.0.4"
+    "typescript": "5.1.3"
   },
   "peerDependencies": {
-    "@nestjs/common": "^9.0.0",
-    "@nestjs/core": "^9.0.0",
+    "@nestjs/common": "^9.0.0 || ^10.0.0",
+    "@nestjs/core": "^9.0.0 || ^10.0.0",
     "reflect-metadata": "0.1.13",
     "rxjs": "^7.2.0"
   },