@nestjs/cqrs 10.2.8 → 11.0.0-next.2

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

@@ -1,3 +1,4 @@
+import { AsyncContext } from '../../scopes/async.context';
 import { IEvent } from './event.interface';
 /**
  * Represents an event bus.
@@ -6,13 +7,49 @@ export interface IEventBus<EventBase extends IEvent = IEvent> {
     /**
      * Publishes an event.
      * @param event The event to publish.
-     * @param context The context.
      */
-    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 context The context.
+     * @param dispatcherContext Dispatcher context
+     * @param asyncContext Async context
      */
-    publishAll<TEvent extends EventBase, TContext = unknown>(events: TEvent[], context?: TContext): any;
+    publishAll<TEvent extends EventBase, TContext = unknown>(events: TEvent[], dispatcherContext: TContext, asyncContext: AsyncContext): any;
 }

package/dist/interfaces/events/event-id-provider.interface.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '@nestjs/common';
+import { IEvent } from './event.interface';
+export interface EventIdProvider<EventBase extends IEvent = IEvent> {
+    /**
+     * Retrieves the unique identifier for the given event instance.
+     * Returns null if the event is not associated with any handler.
+     *
+     * @param event - The event type for which to retrieve the ID.
+     * @returns The unique identifier for the event, or null if not connected to any handler.
+     */
+    getEventId(event: Type<EventBase>): string | null;
+}

package/dist/interfaces/events/event-id-provider.interface.js

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

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

@@ -1,15 +1,18 @@
+import { AsyncContext } from '../../scopes';
 import { IEvent } from './event.interface';
 export interface IEventPublisher<EventBase extends IEvent = IEvent> {
     /**
      * Publishes an event.
      * @param event The event to publish.
-     * @param context The context.
+     * @param dispatcherContext Dispatcher context or undefined.
+     * @param asyncContext The async context (if scoped).
      */
-    publish<TEvent extends EventBase>(event: TEvent, context?: unknown): any;
+    publish<TEvent extends EventBase>(event: TEvent, dispatcherContext?: unknown, asyncContext?: AsyncContext): any;
     /**
      * Publishes multiple events.
      * @param events The events to publish.
-     * @param context The context.
+     * @param dispatcherContext Dispatcher context or undefined.
+     * @param asyncContext The async context (if scoped).
      */
-    publishAll?<TEvent extends EventBase>(events: TEvent[], context?: unknown): any;
+    publishAll?<TEvent extends EventBase>(events: TEvent[], dispatcherContext?: unknown, asyncContext?: AsyncContext): any;
 }

package/dist/interfaces/index.d.ts

@@ -2,11 +2,13 @@ export * from './commands/command-bus.interface';
 export * from './commands/command-handler.interface';
 export * from './commands/command-publisher.interface';
 export * from './commands/command.interface';
+export * from './cqrs-module-options.interface';
 export * from './events/event-bus.interface';
 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 './events/event-id-provider.interface';
 export * from './exceptions/unhandled-exception-info.interface';
 export * from './exceptions/unhandled-exception-publisher.interface';
 export * from './queries/query-bus.interface';

package/dist/interfaces/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];
@@ -14,11 +18,13 @@ __exportStar(require("./commands/command-bus.interface"), exports);
 __exportStar(require("./commands/command-handler.interface"), exports);
 __exportStar(require("./commands/command-publisher.interface"), exports);
 __exportStar(require("./commands/command.interface"), exports);
+__exportStar(require("./cqrs-module-options.interface"), exports);
 __exportStar(require("./events/event-bus.interface"), exports);
 __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("./events/event-id-provider.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);

package/dist/interfaces/providers-introspection-result.interface.d.ts

@@ -0,0 +1,10 @@
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { ICommandHandler } from './commands/command-handler.interface';
+import { IEventHandler } from './events/event-handler.interface';
+import { IQueryHandler } from './queries/query-handler.interface';
+export interface ProvidersIntrospectionResult {
+    events?: InstanceWrapper<IEventHandler>[];
+    queries?: InstanceWrapper<IQueryHandler>[];
+    commands?: InstanceWrapper<ICommandHandler>[];
+    sagas?: InstanceWrapper<object>[];
+}

package/dist/interfaces/providers-introspection-result.interface.js

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

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

@@ -1,3 +1,5 @@
+import { Query } from '../../classes/query';
+import { AsyncContext } from '../../scopes/async.context';
 import { IQuery } from './query.interface';
 /**
  * Represents a query bus.
@@ -7,5 +9,20 @@ 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>;
+    execute<TResult>(query: Query<TResult>): Promise<TResult>;
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<T extends QueryBase, TResult = any>(query: T): Promise<TResult>;
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<TResult>(query: Query<TResult>, asyncContext: AsyncContext): Promise<TResult>;
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<T extends QueryBase, TResult = any>(query: T, asyncContext: AsyncContext): Promise<TResult>;
 }

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

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

package/dist/interfaces/saga.type.d.ts

@@ -1,4 +1,4 @@
 import { Observable } from 'rxjs';
 import { ICommand } from './commands/command.interface';
 import { IEvent } from './events/event.interface';
-export declare type ISaga<EventBase extends IEvent = IEvent, CommandBase extends ICommand = ICommand> = (events$: Observable<EventBase>) => Observable<CommandBase>;
+export type ISaga<EventBase extends IEvent = IEvent, CommandBase extends ICommand = ICommand> = (events$: Observable<EventBase>) => Observable<CommandBase>;

package/dist/operators/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];

package/dist/operators/of-type.d.ts

@@ -9,4 +9,4 @@ import { IEvent } from '../interfaces';
  *
  * @return A stream only emitting the filtered instances.
  */
-export declare function ofType<TInput extends IEvent, TOutput extends IEvent>(...types: Type<TOutput>[]): (source: Observable<TInput>) => Observable<TOutput>;
+export declare function ofType<TInput extends IEvent, T extends Type<IEvent>[]>(...types: T): (source: Observable<TInput>) => Observable<T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends Type<infer I> ? I : never : never : never>;

package/dist/operators/of-type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ofType = void 0;
+exports.ofType = ofType;
 const operators_1 = require("rxjs/operators");
 /**
  * Filter values depending on their instance type (comparison is made
@@ -14,4 +14,3 @@ function ofType(...types) {
     const isInstanceOf = (event) => !!types.find((classType) => event instanceof classType);
     return (source) => source.pipe((0, operators_1.filter)(isInstanceOf));
 }
-exports.ofType = ofType;

package/dist/query-bus.d.ts

@@ -1,14 +1,19 @@
 import { Type } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import 'reflect-metadata';
-import { IQuery, IQueryBus, IQueryHandler, IQueryPublisher, IQueryResult } from './interfaces';
+import { Query } from './classes/query';
+import { CqrsModuleOptions, IQuery, IQueryBus, IQueryHandler, IQueryPublisher, IQueryResult } from './interfaces';
+import { AsyncContext } from './scopes';
 import { ObservableBus } from './utils/observable-bus';
-export declare type QueryHandlerType<QueryBase extends IQuery = IQuery, QueryResultBase extends IQueryResult = IQueryResult> = Type<IQueryHandler<QueryBase, QueryResultBase>>;
+export type QueryHandlerType<QueryBase extends IQuery = IQuery, QueryResultBase extends IQueryResult = IQueryResult> = Type<IQueryHandler<QueryBase, QueryResultBase>>;
 export declare class QueryBus<QueryBase extends IQuery = IQuery> extends ObservableBus<QueryBase> implements IQueryBus<QueryBase> {
     private readonly moduleRef;
+    private readonly options?;
+    private readonly logger;
     private handlers;
     private _publisher;
-    constructor(moduleRef: ModuleRef);
+    constructor(moduleRef: ModuleRef, options?: CqrsModuleOptions | undefined);
     /**
      * Returns the publisher.
      */
@@ -19,14 +24,29 @@ export declare class QueryBus<QueryBase extends IQuery = IQuery> extends Observa
      * @param _publisher The publisher to set.
      */
     set publisher(_publisher: IQueryPublisher<QueryBase>);
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<TResult>(query: Query<TResult>): Promise<TResult>;
     /**
      * 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;
-    protected registerHandler(handler: QueryHandlerType<QueryBase>): void;
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<TResult>(query: Query<TResult>, asyncContext: AsyncContext): Promise<TResult>;
+    /**
+     * Executes a query.
+     * @param query The query to execute.
+     */
+    execute<T extends QueryBase, TResult = any>(query: T, asyncContext: AsyncContext): Promise<TResult>;
+    bind<T extends QueryBase, TResult extends IQueryResult = any>(handler: InstanceWrapper<IQueryHandler<T, TResult>>, queryId: string): void;
+    register(handlers?: InstanceWrapper<IQueryHandler<QueryBase>>[]): void;
+    protected registerHandler(handler: InstanceWrapper<IQueryHandler<QueryBase>>): void;
     private getQueryId;
     private reflectQueryId;
     private useDefaultPublisher;

package/dist/query-bus.js

@@ -8,22 +8,35 @@ 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 QueryBus_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBus = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 require("reflect-metadata");
-const constants_1 = require("./decorators/constants");
+const constants_1 = require("./constants");
+const constants_2 = require("./decorators/constants");
 const exceptions_1 = require("./exceptions");
 const invalid_query_handler_exception_1 = require("./exceptions/invalid-query-handler.exception");
 const default_query_pubsub_1 = require("./helpers/default-query-pubsub");
+const scopes_1 = require("./scopes");
 const observable_bus_1 = require("./utils/observable-bus");
-let QueryBus = class QueryBus extends observable_bus_1.ObservableBus {
-    constructor(moduleRef) {
+let QueryBus = QueryBus_1 = class QueryBus extends observable_bus_1.ObservableBus {
+    constructor(moduleRef, options) {
         super();
         this.moduleRef = moduleRef;
+        this.options = options;
+        this.logger = new common_1.Logger(QueryBus_1.name);
         this.handlers = new Map();
-        this.useDefaultPublisher();
+        if (this.options?.queryPublisher) {
+            this._publisher = this.options.queryPublisher;
+        }
+        else {
+            this.useDefaultPublisher();
+        }
     }
     /**
      * Returns the publisher.
@@ -43,7 +56,7 @@ let QueryBus = class QueryBus extends observable_bus_1.ObservableBus {
      * Executes a query.
      * @param query The query to execute.
      */
-    async execute(query) {
+    async execute(query, asyncContext) {
         const queryId = this.getQueryId(query);
         const handler = this.handlers.get(queryId);
         if (!handler) {
@@ -51,37 +64,51 @@ let QueryBus = class QueryBus extends observable_bus_1.ObservableBus {
             throw new exceptions_1.QueryHandlerNotFoundException(queryName);
         }
         this._publisher.publish(query);
-        const result = await handler.execute(query);
-        return result;
+        return (await handler(query, asyncContext));
     }
     bind(handler, queryId) {
-        this.handlers.set(queryId, handler);
+        if (handler.isDependencyTreeStatic()) {
+            const instance = handler.instance;
+            if (!instance.execute) {
+                throw new invalid_query_handler_exception_1.InvalidQueryHandlerException();
+            }
+            this.handlers.set(queryId, (query) => instance.execute(query));
+            return;
+        }
+        this.handlers.set(queryId, async (query, context) => {
+            context ??= scopes_1.AsyncContext.of(query) ?? new scopes_1.AsyncContext();
+            this.moduleRef.registerRequestByContextId(context, context.id);
+            const instance = await this.moduleRef.resolve(handler.metatype, context.id, {
+                strict: false,
+            });
+            return instance.execute(query);
+        });
     }
     register(handlers = []) {
         handlers.forEach((handler) => this.registerHandler(handler));
     }
     registerHandler(handler) {
-        const instance = this.moduleRef.get(handler, { strict: false });
-        if (!instance) {
-            return;
-        }
-        const target = this.reflectQueryId(handler);
+        const typeRef = handler.metatype;
+        const target = this.reflectQueryId(typeRef);
         if (!target) {
             throw new invalid_query_handler_exception_1.InvalidQueryHandlerException();
         }
-        this.bind(instance, target);
+        if (this.handlers.has(target)) {
+            this.logger.warn(`Query handler [${typeRef.name}] is already registered. Overriding previously registered handler.`);
+        }
+        this.bind(handler, target);
     }
     getQueryId(query) {
         const { constructor: queryType } = Object.getPrototypeOf(query);
-        const queryMetadata = Reflect.getMetadata(constants_1.QUERY_METADATA, queryType);
+        const queryMetadata = Reflect.getMetadata(constants_2.QUERY_METADATA, queryType);
         if (!queryMetadata) {
             throw new exceptions_1.QueryHandlerNotFoundException(queryType.name);
         }
         return queryMetadata.id;
     }
     reflectQueryId(handler) {
-        const query = Reflect.getMetadata(constants_1.QUERY_HANDLER_METADATA, handler);
-        const queryMetadata = Reflect.getMetadata(constants_1.QUERY_METADATA, query);
+        const query = Reflect.getMetadata(constants_2.QUERY_HANDLER_METADATA, handler);
+        const queryMetadata = Reflect.getMetadata(constants_2.QUERY_METADATA, query);
         return queryMetadata.id;
     }
     useDefaultPublisher() {
@@ -92,8 +119,10 @@ let QueryBus = class QueryBus extends observable_bus_1.ObservableBus {
         return constructor.name;
     }
 };
-QueryBus = __decorate([
+exports.QueryBus = QueryBus;
+exports.QueryBus = QueryBus = QueryBus_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.ModuleRef])
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(constants_1.CQRS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
 ], QueryBus);
-exports.QueryBus = QueryBus;

package/dist/scopes/async.context.d.ts

@@ -0,0 +1,30 @@
+export declare const ASYNC_CONTEXT_ATTRIBUTE: unique symbol;
+/**
+ * Represents the context of an asynchronous operation.
+ */
+export declare class AsyncContext {
+    readonly id: import("@nestjs/core").ContextId;
+    /**
+     * Attaches the context to an object.
+     * @param target The object to attach the context to.
+     */
+    attachTo(target: object): void;
+    /**
+     * Checks if target is already attached to any async context.
+     * @param target The object to check.
+     * @returns "true" if the target is attached to an async context, "false" otherwise.
+     */
+    static isAttached(target: object): boolean;
+    /**
+     * Merges the context of an asynchronous operation from a given command, query, or event to another object.
+     * @param from A command, query, or event.
+     * @param to A command, query, or event to merge the context to.
+     */
+    static merge(from: object, to: object): void;
+    /**
+     * Gets the context of an asynchronous operation from a given object.
+     * @param target A command, query, or event.
+     * @returns An "AsyncContext" instance or "undefined" if the context is not found.
+     */
+    static of(target: object): AsyncContext | undefined;
+}

package/dist/scopes/async.context.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncContext = exports.ASYNC_CONTEXT_ATTRIBUTE = void 0;
+const core_1 = require("@nestjs/core");
+exports.ASYNC_CONTEXT_ATTRIBUTE = Symbol('ASYNC_CONTEXT_ATTRIBUTE');
+/**
+ * Represents the context of an asynchronous operation.
+ */
+class AsyncContext {
+    constructor() {
+        this.id = core_1.ContextIdFactory.create();
+    }
+    /**
+     * Attaches the context to an object.
+     * @param target The object to attach the context to.
+     */
+    attachTo(target) {
+        Object.defineProperty(target, exports.ASYNC_CONTEXT_ATTRIBUTE, {
+            value: this,
+            enumerable: false,
+        });
+    }
+    /**
+     * Checks if target is already attached to any async context.
+     * @param target The object to check.
+     * @returns "true" if the target is attached to an async context, "false" otherwise.
+     */
+    static isAttached(target) {
+        return !!target[exports.ASYNC_CONTEXT_ATTRIBUTE];
+    }
+    /**
+     * Merges the context of an asynchronous operation from a given command, query, or event to another object.
+     * @param from A command, query, or event.
+     * @param to A command, query, or event to merge the context to.
+     */
+    static merge(from, to) {
+        if (!from || !to) {
+            return;
+        }
+        const fromContext = from[exports.ASYNC_CONTEXT_ATTRIBUTE];
+        if (!fromContext) {
+            return;
+        }
+        Object.defineProperty(to, exports.ASYNC_CONTEXT_ATTRIBUTE, {
+            value: fromContext,
+            enumerable: false,
+        });
+    }
+    /**
+     * Gets the context of an asynchronous operation from a given object.
+     * @param target A command, query, or event.
+     * @returns An "AsyncContext" instance or "undefined" if the context is not found.
+     */
+    static of(target) {
+        return target[exports.ASYNC_CONTEXT_ATTRIBUTE];
+    }
+}
+exports.AsyncContext = AsyncContext;

package/dist/scopes/index.d.ts

@@ -0,0 +1 @@
+export * from './async.context';

package/dist/scopes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async.context"), exports);

package/dist/services/explorer.service.d.ts

@@ -1,14 +1,12 @@
-import { Type } from '@nestjs/common';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { Module } from '@nestjs/core/injector/module';
 import { ModulesContainer } from '@nestjs/core/injector/modules-container';
 import { IEvent } from '../interfaces';
-import { CqrsOptions } from '../interfaces/cqrs-options.interface';
+import { ProvidersIntrospectionResult } from '../interfaces/providers-introspection-result.interface';
 export declare class ExplorerService<EventBase extends IEvent = IEvent> {
     private readonly modulesContainer;
     constructor(modulesContainer: ModulesContainer);
-    explore(): CqrsOptions;
-    flatMap<T>(modules: Module[], callback: (instance: InstanceWrapper) => Type<any> | undefined): Type<T>[];
-    filterProvider(wrapper: InstanceWrapper, metadataKey: string): Type<any> | undefined;
-    extractMetadata(instance: Record<string, any>, metadataKey: string): Type<any>;
+    explore(): ProvidersIntrospectionResult;
+    flatMap<T extends object>(modules: Module[], callback: (instance: InstanceWrapper) => InstanceWrapper<any> | undefined): InstanceWrapper<T>[];
+    filterByMetadataKey(wrapper: InstanceWrapper, metadataKey: string): InstanceWrapper<any> | undefined;
 }

package/dist/services/explorer.service.js

@@ -19,35 +19,35 @@ let ExplorerService = class ExplorerService {
     }
     explore() {
         const modules = [...this.modulesContainer.values()];
-        const commands = this.flatMap(modules, (instance) => this.filterProvider(instance, constants_1.COMMAND_HANDLER_METADATA));
-        const queries = this.flatMap(modules, (instance) => this.filterProvider(instance, constants_1.QUERY_HANDLER_METADATA));
-        const events = this.flatMap(modules, (instance) => this.filterProvider(instance, constants_1.EVENTS_HANDLER_METADATA));
-        const sagas = this.flatMap(modules, (instance) => this.filterProvider(instance, constants_1.SAGA_METADATA));
+        const commands = this.flatMap(modules, (instance) => this.filterByMetadataKey(instance, constants_1.COMMAND_HANDLER_METADATA));
+        const queries = this.flatMap(modules, (instance) => this.filterByMetadataKey(instance, constants_1.QUERY_HANDLER_METADATA));
+        const events = this.flatMap(modules, (instance) => this.filterByMetadataKey(instance, constants_1.EVENTS_HANDLER_METADATA));
+        const sagas = this.flatMap(modules, (instance) => this.filterByMetadataKey(instance, constants_1.SAGA_METADATA));
         return { commands, queries, events, sagas };
     }
     flatMap(modules, callback) {
         const items = modules
-            .map((module) => [...module.providers.values()].map(callback))
+            .map((moduleRef) => [...moduleRef.providers.values()].map(callback))
             .reduce((a, b) => a.concat(b), []);
-        return items.filter((element) => !!element);
+        return items.filter((item) => !!item);
     }
-    filterProvider(wrapper, metadataKey) {
+    filterByMetadataKey(wrapper, metadataKey) {
         const { instance } = wrapper;
         if (!instance) {
-            return undefined;
+            return;
         }
-        return this.extractMetadata(instance, metadataKey);
-    }
-    extractMetadata(instance, metadataKey) {
         if (!instance.constructor) {
             return;
         }
         const metadata = Reflect.getMetadata(metadataKey, instance.constructor);
-        return metadata ? instance.constructor : undefined;
+        if (!metadata) {
+            return;
+        }
+        return wrapper;
     }
 };
-ExplorerService = __decorate([
+exports.ExplorerService = ExplorerService;
+exports.ExplorerService = ExplorerService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [modules_container_1.ModulesContainer])
 ], ExplorerService);
-exports.ExplorerService = ExplorerService;

package/dist/storages/aggregate-root.storage.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@nestjs/common';
+import { AggregateRoot } from '../aggregate-root';
+import { EventBus } from '../event-bus';
+export declare class AggregateRootStorage {
+    private static storage;
+    static add(type: Type<AggregateRoot>): void;
+    static mergeContext(eventBus: EventBus): void;
+}

package/dist/storages/aggregate-root.storage.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRootStorage = void 0;
+class AggregateRootStorage {
+    static add(type) {
+        this.storage.push(type);
+    }
+    static mergeContext(eventBus) {
+        for (const item of this.storage) {
+            item.prototype.publish = function (event) {
+                eventBus.publish(event);
+            };
+            item.prototype.publishAll = function (events) {
+                eventBus.publishAll(events);
+            };
+        }
+        this.storage = [];
+    }
+}
+exports.AggregateRootStorage = AggregateRootStorage;
+AggregateRootStorage.storage = [];