@nestjs/cqrs 10.2.8 → 11.0.0-next.2

package/dist/event-bus.d.ts

@@ -1,20 +1,23 @@
 import { OnModuleDestroy, Type } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { Observable, Subscription } from 'rxjs';
 import { CommandBus } from './command-bus';
-import { IEvent, IEventBus, IEventHandler, IEventPublisher, ISaga } from './interfaces';
+import { CqrsModuleOptions, EventIdProvider, IEvent, IEventBus, IEventHandler, IEventPublisher, ISaga } from './interfaces';
+import { AsyncContext } from './scopes';
 import { UnhandledExceptionBus } from './unhandled-exception-bus';
 import { ObservableBus } from './utils';
-export declare type EventHandlerType<EventBase extends IEvent = IEvent> = Type<IEventHandler<EventBase>>;
+export 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;
+    private readonly options?;
+    protected eventIdProvider: EventIdProvider<EventBase>;
     protected readonly subscriptions: Subscription[];
     private _publisher;
     private readonly _logger;
-    constructor(commandBus: CommandBus, moduleRef: ModuleRef, unhandledExceptionBus: UnhandledExceptionBus);
+    constructor(commandBus: CommandBus, moduleRef: ModuleRef, unhandledExceptionBus: UnhandledExceptionBus, options?: CqrsModuleOptions | undefined);
     /**
      * Returns the publisher.
      * Default publisher is `DefaultPubSub` (in memory).
@@ -31,16 +34,54 @@ export declare class EventBus<EventBase extends IEvent = IEvent> extends Observa
      * Publishes an event.
      * @param event The event to publish.
      */
-    publish<TEvent extends EventBase, TContext = unknown>(event: TEvent, context?: TContext): any;
+    publish<TEvent extends EventBase>(event: TEvent): any;
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     * @param asyncContext Async context
+     */
+    publish<TEvent extends EventBase>(event: TEvent, asyncContext: AsyncContext): any;
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     * @param dispatcherContext Dispatcher context
+     */
+    publish<TEvent extends EventBase, TContext = unknown>(event: TEvent, dispatcherContext: TContext): any;
+    /**
+     * Publishes an event.
+     * @param event The event to publish.
+     * @param dispatcherContext Dispatcher context
+     * @param asyncContext Async context
+     */
+    publish<TEvent extends EventBase, TContext = unknown>(event: TEvent, dispatcherContext: TContext, asyncContext: AsyncContext): any;
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     */
+    publishAll<TEvent extends EventBase>(events: TEvent[]): any;
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     * @param asyncContext Async context
+     */
+    publishAll<TEvent extends EventBase>(events: TEvent[], asyncContext: AsyncContext): any;
+    /**
+     * Publishes multiple events.
+     * @param events The events to publish.
+     * @param dispatcherContext Dispatcher context
+     */
+    publishAll<TEvent extends EventBase, TContext = unknown>(events: TEvent[], dispatcherContext: TContext): any;
     /**
      * Publishes multiple events.
      * @param events The events to publish.
+     * @param dispatcherContext Dispatcher context
+     * @param asyncContext Async context
      */
-    publishAll<TEvent extends EventBase, TContext = unknown>(events: TEvent[], context?: TContext): any;
-    bind(handler: IEventHandler<EventBase>, id: string): void;
-    registerSagas(types?: Type<unknown>[]): void;
-    register(handlers?: EventHandlerType<EventBase>[]): void;
-    protected registerHandler(handler: EventHandlerType<EventBase>): void;
+    publishAll<TEvent extends EventBase, TContext = unknown>(events: TEvent[], dispatcherContext: TContext, asyncContext: AsyncContext): any;
+    bind(handler: InstanceWrapper<IEventHandler<EventBase>>, id: string): void;
+    registerSagas(wrappers?: InstanceWrapper<object>[]): void;
+    register(handlers?: InstanceWrapper<IEventHandler<EventBase>>[]): void;
+    protected registerHandler(handler: InstanceWrapper<IEventHandler<EventBase>>): void;
     protected ofEventId(id: string): Observable<EventBase>;
     protected registerSaga(saga: ISaga<EventBase>): void;
     private reflectEvents;

package/dist/event-bus.js

@@ -8,6 +8,9 @@ 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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var EventBus_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventBus = void 0;
@@ -16,22 +19,31 @@ const core_1 = require("@nestjs/core");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const command_bus_1 = require("./command-bus");
-const constants_1 = require("./decorators/constants");
+const constants_1 = require("./constants");
+const constants_2 = require("./decorators/constants");
 const exceptions_1 = require("./exceptions");
-const default_get_event_id_1 = require("./helpers/default-get-event-id");
+const default_event_id_provider_1 = require("./helpers/default-event-id-provider");
 const default_pubsub_1 = require("./helpers/default-pubsub");
+const scopes_1 = require("./scopes");
 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, unhandledExceptionBus) {
+    constructor(commandBus, moduleRef, unhandledExceptionBus, options) {
         super();
         this.commandBus = commandBus;
         this.moduleRef = moduleRef;
         this.unhandledExceptionBus = unhandledExceptionBus;
+        this.options = options;
         this._logger = new common_1.Logger(EventBus_1.name);
         this.subscriptions = [];
-        this.getEventId = default_get_event_id_1.defaultGetEventId;
-        this.useDefaultPublisher();
+        this.eventIdProvider =
+            this.options?.eventIdProvider ?? default_event_id_provider_1.defaultEventIdProvider;
+        if (this.options?.eventPublisher) {
+            this._publisher = this.options.eventPublisher;
+        }
+        else {
+            this.useDefaultPublisher();
+        }
     }
     /**
      * Returns the publisher.
@@ -54,24 +66,61 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
     /**
      * Publishes an event.
      * @param event The event to publish.
+     * @param dispatcherOrAsyncContext Dispatcher context or async context
+     * @param asyncContext Async context
      */
-    publish(event, context) {
-        return this._publisher.publish(event, context);
+    publish(event, dispatcherOrAsyncContext, asyncContext) {
+        if (!asyncContext && dispatcherOrAsyncContext instanceof scopes_1.AsyncContext) {
+            asyncContext = dispatcherOrAsyncContext;
+            dispatcherOrAsyncContext = undefined;
+        }
+        if (asyncContext) {
+            asyncContext.attachTo(event);
+        }
+        return this._publisher.publish(event, dispatcherOrAsyncContext, asyncContext);
     }
     /**
      * Publishes multiple events.
      * @param events The events to publish.
+     * @param dispatcherOrAsyncContext Dispatcher context or async context
+     * @param asyncContext Async context
      */
-    publishAll(events, context) {
+    publishAll(events, dispatcherOrAsyncContext, asyncContext) {
+        if (!asyncContext && dispatcherOrAsyncContext instanceof scopes_1.AsyncContext) {
+            asyncContext = dispatcherOrAsyncContext;
+            dispatcherOrAsyncContext = undefined;
+        }
+        if (asyncContext) {
+            events.forEach((event) => {
+                if (scopes_1.AsyncContext.isAttached(event)) {
+                    return;
+                }
+                asyncContext.attachTo(event);
+            });
+        }
         if (this._publisher.publishAll) {
-            return this._publisher.publishAll(events, context);
+            return this._publisher.publishAll(events, dispatcherOrAsyncContext, asyncContext);
         }
-        return (events || []).map((event) => this._publisher.publish(event, context));
+        return (events || []).map((event) => this._publisher.publish(event, dispatcherOrAsyncContext, asyncContext));
     }
     bind(handler, id) {
         const stream$ = id ? this.ofEventId(id) : this.subject$;
+        const deferred = handler.isDependencyTreeStatic()
+            ? (event) => () => {
+                return Promise.resolve(handler.instance.handle(event));
+            }
+            : (event) => async () => {
+                const asyncContext = scopes_1.AsyncContext.of(event) ?? new scopes_1.AsyncContext();
+                const instance = await this.moduleRef.resolve(handler.metatype, asyncContext.id, {
+                    strict: false,
+                });
+                return instance.handle(event);
+            };
         const subscription = stream$
-            .pipe((0, operators_1.mergeMap)((event) => (0, rxjs_1.defer)(() => Promise.resolve(handler.handle(event))).pipe((0, operators_1.catchError)((error) => {
+            .pipe((0, operators_1.mergeMap)((event) => (0, rxjs_1.defer)(deferred(event)).pipe((0, operators_1.catchError)((error) => {
+            if (this.options?.rethrowUnhandled) {
+                throw error;
+            }
             const unhandledError = this.mapToUnhandledErrorInfo(event, error);
             this.unhandledExceptionBus.publish(unhandledError);
             this._logger.error(`"${handler.constructor.name}" has thrown an unhandled exception.`, error);
@@ -80,15 +129,24 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
             .subscribe();
         this.subscriptions.push(subscription);
     }
-    registerSagas(types = []) {
-        const sagas = types
-            .map((target) => {
-            const metadata = Reflect.getMetadata(constants_1.SAGA_METADATA, target) || [];
-            const instance = this.moduleRef.get(target, { strict: false });
-            if (!instance) {
-                throw new exceptions_1.InvalidSagaException();
+    registerSagas(wrappers = []) {
+        const sagas = wrappers
+            .map((wrapper) => {
+            const { metatype: target } = wrapper;
+            const metadata = Reflect.getMetadata(constants_2.SAGA_METADATA, target) ?? [];
+            if (!wrapper.isDependencyTreeStatic()) {
+                throw new exceptions_1.UnsupportedSagaScopeException();
             }
-            return metadata.map((key) => instance[key].bind(instance));
+            const instance = wrapper.instance;
+            return metadata.map((key) => {
+                const sagaFn = instance[key].bind(instance);
+                Object.defineProperty(sagaFn, 'name', {
+                    value: key,
+                    writable: false,
+                    configurable: false,
+                });
+                return sagaFn;
+            });
         })
             .reduce((a, b) => a.concat(b), []);
         sagas.forEach((saga) => this.registerSaga(saga));
@@ -97,15 +155,21 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
         handlers.forEach((handler) => this.registerHandler(handler));
     }
     registerHandler(handler) {
-        const instance = this.moduleRef.get(handler, { strict: false });
-        if (!instance) {
-            return;
-        }
-        const events = this.reflectEvents(handler);
-        events.map((event) => this.bind(instance, (0, default_get_event_id_1.defaultReflectEventId)(event)));
+        const typeRef = handler.metatype;
+        const events = this.reflectEvents(typeRef);
+        events.forEach((event) => {
+            const eventId = this.eventIdProvider.getEventId(event);
+            this.bind(handler, eventId);
+        });
     }
     ofEventId(id) {
-        return this.subject$.pipe((0, operators_1.filter)((event) => this.getEventId(event) === id));
+        return this.subject$.pipe((0, operators_1.filter)((event) => {
+            const { constructor } = Object.getPrototypeOf(event);
+            if (!constructor) {
+                return false;
+            }
+            return this.eventIdProvider.getEventId(constructor) === id;
+        }));
     }
     registerSaga(saga) {
         if (typeof saga !== 'function') {
@@ -116,7 +180,18 @@ 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.defer)(() => this.commandBus.execute(command)).pipe((0, operators_1.catchError)((error) => {
+            .pipe((0, operators_1.filter)((e) => !!e), (0, operators_1.catchError)((error) => {
+            if (this.options?.rethrowUnhandled) {
+                throw error;
+            }
+            const unhandledError = this.mapToUnhandledErrorInfo(saga.name, error);
+            this.unhandledExceptionBus.publish(unhandledError);
+            this._logger.error(`Saga "${saga.name}" has thrown an unhandled exception.`, error);
+            return (0, rxjs_1.of)();
+        }), (0, operators_1.mergeMap)((command) => (0, rxjs_1.defer)(() => this.commandBus.execute(command)).pipe((0, operators_1.catchError)((error) => {
+            if (this.options?.rethrowUnhandled) {
+                throw error;
+            }
             const unhandledError = this.mapToUnhandledErrorInfo(command, error);
             this.unhandledExceptionBus.publish(unhandledError);
             this._logger.error(`Command handler which execution was triggered by Saga has thrown an unhandled exception.`, error);
@@ -126,7 +201,7 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
         this.subscriptions.push(subscription);
     }
     reflectEvents(handler) {
-        return Reflect.getMetadata(constants_1.EVENTS_HANDLER_METADATA, handler);
+        return Reflect.getMetadata(constants_2.EVENTS_HANDLER_METADATA, handler);
     }
     useDefaultPublisher() {
         this._publisher = new default_pubsub_1.DefaultPubSub(this.subject$);
@@ -138,10 +213,12 @@ let EventBus = EventBus_1 = class EventBus extends utils_1.ObservableBus {
         };
     }
 };
-EventBus = EventBus_1 = __decorate([
+exports.EventBus = EventBus;
+exports.EventBus = EventBus = EventBus_1 = __decorate([
     (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(constants_1.CQRS_MODULE_OPTIONS)),
     __metadata("design:paramtypes", [command_bus_1.CommandBus,
         core_1.ModuleRef,
-        unhandled_exception_bus_1.UnhandledExceptionBus])
+        unhandled_exception_bus_1.UnhandledExceptionBus, Object])
 ], EventBus);
-exports.EventBus = EventBus;

package/dist/event-publisher.d.ts

@@ -1,6 +1,7 @@
 import { AggregateRoot } from './aggregate-root';
 import { EventBus } from './event-bus';
 import { IEvent } from './interfaces';
+import { AsyncContext } from './scopes';
 export interface Constructor<T> {
     new (...args: any[]): T;
 }
@@ -11,12 +12,14 @@ export declare class EventPublisher<EventBase extends IEvent = IEvent> {
      * 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.
+     * @param asyncContext The async context (if scoped).
      */
-    mergeClassContext<T extends Constructor<AggregateRoot<EventBase>>>(metatype: T): T;
+    mergeClassContext<T extends Constructor<AggregateRoot<EventBase>>>(metatype: T, asyncContext?: AsyncContext): 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.
+     * @param asyncContext The async context (if scoped).
      */
-    mergeObjectContext<T extends AggregateRoot<EventBase>>(object: T): T;
+    mergeObjectContext<T extends AggregateRoot<EventBase>>(object: T, asyncContext?: AsyncContext): T;
 }

package/dist/event-publisher.js

@@ -20,15 +20,16 @@ let EventPublisher = class EventPublisher {
      * 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.
+     * @param asyncContext The async context (if scoped).
      */
-    mergeClassContext(metatype) {
+    mergeClassContext(metatype, asyncContext) {
         const eventBus = this.eventBus;
         return class extends metatype {
             publish(event) {
-                eventBus.publish(event, this);
+                eventBus.publish(event, this, asyncContext);
             }
             publishAll(events) {
-                eventBus.publishAll(events, this);
+                eventBus.publishAll(events, this, asyncContext);
             }
         };
     }
@@ -36,20 +37,21 @@ 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.
+     * @param asyncContext The async context (if scoped).
      */
-    mergeObjectContext(object) {
+    mergeObjectContext(object, asyncContext) {
         const eventBus = this.eventBus;
         object.publish = (event) => {
-            eventBus.publish(event, object);
+            eventBus.publish(event, object, asyncContext);
         };
         object.publishAll = (events) => {
-            eventBus.publishAll(events, object);
+            eventBus.publishAll(events, object, asyncContext);
         };
         return object;
     }
 };
-EventPublisher = __decorate([
+exports.EventPublisher = EventPublisher;
+exports.EventPublisher = EventPublisher = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [event_bus_1.EventBus])
 ], EventPublisher);
-exports.EventPublisher = EventPublisher;

package/dist/exceptions/command-not-found.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandlerNotFoundException = void 0;
 class CommandHandlerNotFoundException extends Error {
     constructor(commandName) {
-        super(`The command handler for the "${commandName}" command was not found!`);
+        super(`No handler found for the command: "${commandName}".`);
     }
 }
 exports.CommandHandlerNotFoundException = CommandHandlerNotFoundException;

package/dist/exceptions/index.d.ts

@@ -4,3 +4,4 @@ export * from './invalid-events-handler.exception';
 export * from './invalid-query-handler.exception';
 export * from './invalid-saga.exception';
 export * from './query-not-found.exception';
+export * from './unsupported-saga-scope.exception';

package/dist/exceptions/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -16,3 +20,4 @@ __exportStar(require("./invalid-events-handler.exception"), exports);
 __exportStar(require("./invalid-query-handler.exception"), exports);
 __exportStar(require("./invalid-saga.exception"), exports);
 __exportStar(require("./query-not-found.exception"), exports);
+__exportStar(require("./unsupported-saga-scope.exception"), exports);

package/dist/exceptions/invalid-command-handler.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCommandHandlerException = void 0;
 class InvalidCommandHandlerException extends Error {
     constructor() {
-        super(`Invalid command handler exception (missing @CommandHandler() decorator?)`);
+        super(`An invalid command handler has been provided. Please ensure that the provided handler is a class annotated with @CommandHandler and contains an 'execute' method.`);
     }
 }
 exports.InvalidCommandHandlerException = InvalidCommandHandlerException;

package/dist/exceptions/invalid-events-handler.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidEventsHandlerException = void 0;
 class InvalidEventsHandlerException extends Error {
     constructor() {
-        super(`Invalid event handler exception (missing @EventsHandler() decorator?)`);
+        super(`An invalid events handler has been provided. Please ensure that the provided handler is a class annotated with @EventsHandler and contains a 'handle' method.`);
     }
 }
 exports.InvalidEventsHandlerException = InvalidEventsHandlerException;

package/dist/exceptions/invalid-query-handler.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidQueryHandlerException = void 0;
 class InvalidQueryHandlerException extends Error {
     constructor() {
-        super(`Invalid query handler exception (missing @QueryHandler() decorator?)`);
+        super(`An invalid query handler has been provided. Please ensure that the provided handler is a class annotated with @QueryHandler and contains an 'execute' method.`);
     }
 }
 exports.InvalidQueryHandlerException = InvalidQueryHandlerException;

package/dist/exceptions/invalid-saga.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSagaException = void 0;
 class InvalidSagaException extends Error {
     constructor() {
-        super(`Invalid saga exception. Each saga should return an Observable object`);
+        super(`Invalid saga. Each saga should return Observable stream.`);
     }
 }
 exports.InvalidSagaException = InvalidSagaException;

package/dist/exceptions/query-not-found.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryHandlerNotFoundException = void 0;
 class QueryHandlerNotFoundException extends Error {
     constructor(queryName) {
-        super(`The query handler for the "${queryName}" query was not found!`);
+        super(`No handler found for the query: "${queryName}"`);
     }
 }
 exports.QueryHandlerNotFoundException = QueryHandlerNotFoundException;

package/dist/exceptions/unsupported-saga-scope.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class UnsupportedSagaScopeException extends Error {
+    constructor();
+}

package/dist/exceptions/unsupported-saga-scope.exception.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedSagaScopeException = void 0;
+class UnsupportedSagaScopeException extends Error {
+    constructor() {
+        super(`Request-scoped saga hosts are not supported. Instead, you should retrieve async-context-specific instances within the saga itself, using the "ModuleRef" provider.`);
+    }
+}
+exports.UnsupportedSagaScopeException = UnsupportedSagaScopeException;

package/dist/helpers/default-event-id-provider.d.ts

@@ -0,0 +1,7 @@
+import { Type } from '@nestjs/common';
+import { EventIdProvider, IEvent } from '../interfaces';
+declare class DefaultEventIdProvider<EventBase extends IEvent = IEvent> implements EventIdProvider<EventBase> {
+    getEventId(event: Type<EventBase>): string | null;
+}
+export declare const defaultEventIdProvider: DefaultEventIdProvider<IEvent>;
+export {};

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEventIdProvider = void 0;
+const constants_1 = require("../decorators/constants");
+class DefaultEventIdProvider {
+    getEventId(event) {
+        return Reflect.getMetadata(constants_1.EVENT_METADATA, event)?.id ?? null;
+    }
+}
+exports.defaultEventIdProvider = new DefaultEventIdProvider();

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './aggregate-root';
+export * from './classes';
 export * from './command-bus';
 export * from './cqrs.module';
 export * from './decorators';
@@ -8,5 +9,6 @@ export * from './exceptions';
 export * from './interfaces';
 export * from './operators';
 export * from './query-bus';
+export * from './scopes';
 export * from './unhandled-exception-bus';
 export * from './utils';

package/dist/index.js

@@ -7,7 +7,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -17,6 +21,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate-root"), exports);
+__exportStar(require("./classes"), exports);
 __exportStar(require("./command-bus"), exports);
 __exportStar(require("./cqrs.module"), exports);
 __exportStar(require("./decorators"), exports);
@@ -26,5 +31,6 @@ __exportStar(require("./exceptions"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./operators"), exports);
 __exportStar(require("./query-bus"), exports);
+__exportStar(require("./scopes"), exports);
 __exportStar(require("./unhandled-exception-bus"), exports);
 __exportStar(require("./utils"), exports);

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

@@ -1,3 +1,5 @@
+import { Command } from '../../classes';
+import { AsyncContext } from '../../scopes/async.context';
 import { ICommand } from './command.interface';
 /**
  * Represents a command bus.
@@ -6,6 +8,21 @@ export interface ICommandBus<CommandBase extends ICommand = ICommand> {
     /**
      * 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>;
+    execute<R = void>(command: Command<R>): Promise<R>;
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     * @param context The context to use. Optional.
+     * @returns A promise that, when resolved, will contain the result returned by the command's handler.
+     */
+    execute<R = void>(command: Command<R>, context?: AsyncContext): Promise<R>;
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     * @param context The context to use. Optional.
+     * @returns A promise that, when resolved, will contain the result returned by the command's handler.
+     */
+    execute<T extends CommandBase, R = any>(command: T, context?: AsyncContext): Promise<R>;
 }

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

@@ -1,12 +1,19 @@
+import { Command } from '../../classes';
 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> {
+export type ICommandHandler<TCommand extends ICommand = any, TResult = any> = TCommand extends Command<infer InferredCommandResult> ? {
+    /**
+     * Executes a command.
+     * @param command The command to execute.
+     */
+    execute(command: TCommand): Promise<InferredCommandResult>;
+} : {
     /**
      * Executes a command.
      * @param command The command to execute.
      */
     execute(command: TCommand): Promise<TResult>;
-}
+};

package/dist/interfaces/cqrs-module-options.interface.d.ts

@@ -1,10 +1,40 @@
-import { Type } from '@nestjs/common';
-import { ICommandHandler } from './commands/command-handler.interface';
-import { IEventHandler } from './events/event-handler.interface';
-import { IQueryHandler } from './queries/query-handler.interface';
+import { ICommandPublisher } from './commands/command-publisher.interface';
+import { EventIdProvider } from './events/event-id-provider.interface';
+import { IEventPublisher } from './events/event-publisher.interface';
+import { IUnhandledExceptionPublisher } from './exceptions/unhandled-exception-publisher.interface';
+import { IQueryPublisher } from './queries/query-publisher.interface';
+/**
+ * Options for the CqrsModule.
+ */
 export interface CqrsModuleOptions {
-  events?: Type<IEventHandler>[];
-  queries?: Type<IQueryHandler>[];
-  commands?: Type<ICommandHandler>[];
-  sagas?: Type<any>[];
+    /**
+     * Command publisher to use for publishing commands.
+     * @default DefaultCommandPubSub
+     */
+    commandPublisher?: ICommandPublisher;
+    /**
+     * Event publisher to use for publishing events.
+     * @default DefaultPubSub
+     */
+    eventPublisher?: IEventPublisher;
+    /**
+     * Query publisher to use for publishing queries.
+     * @default DefaultQueryPubSub
+     */
+    queryPublisher?: IQueryPublisher;
+    /**
+     * Unhandled exception publisher to use for publishing unhandled exceptions.
+     * @default DefaultUnhandledExceptionPubSub
+     */
+    unhandledExceptionPublisher?: IUnhandledExceptionPublisher;
+    /**
+     * Event ID provider to use for retrieving event IDs by event instances.
+     * @default DefaultEventIdProvider
+     */
+    eventIdProvider?: EventIdProvider;
+    /**
+     * Whether to rethrow unhandled exceptions.
+     * @default false
+     */
+    rethrowUnhandled?: boolean;
 }