@nestjs/cqrs 10.2.8 → 11.0.0-next.2

package/.circleci/config.yml

@@ -17,7 +17,7 @@ jobs:
   build:
     working_directory: ~/nest
     docker:
-      - image: cimg/node:21.6
+      - image: cimg/node:22.3
     steps:
       - checkout
       - run:
@@ -35,9 +35,37 @@ jobs:
       - run:
           name: Build
           command: npm run build
+  e2e_test:
+    working_directory: ~/nest
+    docker:
+      - image: cimg/node:22.3
+    steps:
+      - checkout
+      - *restore-cache
+      - *install-deps
+      - run:
+          name: e2e tests
+          command: npm run test:e2e
+  test:
+    working_directory: ~/nest
+    docker:
+      - image: cimg/node:22.3
+    steps:
+      - checkout
+      - *restore-cache
+      - *install-deps
+      - run:
+          name: Unit tests
+          command: npm run test
 
 workflows:
   version: 2
   build-and-test:
     jobs:
       - build
+      - test:
+          requires:
+            - build
+      - e2e_test:
+          requires:
+            - build

package/.husky/commit-msg

@@ -1,4 +1 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
 npx --no-install commitlint --edit $1

package/.husky/pre-commit

@@ -1,4 +1 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
 npx --no-install lint-staged

package/dist/classes/command.d.ts

@@ -0,0 +1,9 @@
+import { ICommand } from '../interfaces';
+import { RESULT_TYPE_SYMBOL } from './constants';
+/**
+ * Utility type to extract the result type of a command.
+ */
+export type CommandResult<C extends Command<unknown>> = C extends Command<infer R> ? R : never;
+export declare class Command<T> implements ICommand {
+    readonly [RESULT_TYPE_SYMBOL]: T;
+}

package/dist/classes/command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const constants_1 = require("./constants");
+class Command {
+}
+exports.Command = Command;

package/dist/classes/constants.d.ts

@@ -0,0 +1 @@
+export declare const RESULT_TYPE_SYMBOL: unique symbol;

package/dist/classes/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESULT_TYPE_SYMBOL = void 0;
+exports.RESULT_TYPE_SYMBOL = Symbol('RESULT_TYPE');

package/dist/classes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './command';
+export * from './query';

package/dist/classes/index.js

@@ -0,0 +1,18 @@
+"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("./command"), exports);
+__exportStar(require("./query"), exports);

package/dist/classes/query.d.ts

@@ -0,0 +1,9 @@
+import { IQuery } from '../interfaces';
+import { RESULT_TYPE_SYMBOL } from './constants';
+/**
+ * Utility type to extract the result type of a query.
+ */
+export type QueryResult<C extends Query<unknown>> = C extends Query<infer R> ? R : never;
+export declare class Query<T> implements IQuery {
+    readonly [RESULT_TYPE_SYMBOL]: T;
+}

package/dist/classes/query.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const constants_1 = require("./constants");
+class Query {
+}
+exports.Query = Query;

package/dist/command-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 { ICommand, ICommandBus, ICommandHandler, ICommandPublisher } from './interfaces/index';
+import { Command } from './classes';
+import { CqrsModuleOptions, ICommand, ICommandBus, ICommandHandler, ICommandPublisher } from './interfaces/index';
+import { AsyncContext } from './scopes/async.context';
 import { ObservableBus } from './utils/observable-bus';
-export declare type CommandHandlerType = Type<ICommandHandler<ICommand>>;
+export type CommandHandlerType<T extends ICommand = ICommand> = Type<ICommandHandler<T>>;
 export declare class CommandBus<CommandBase extends ICommand = ICommand> extends ObservableBus<CommandBase> implements ICommandBus<CommandBase> {
     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.
      * Default publisher is `DefaultCommandPubSub` (in memory).
@@ -25,10 +30,24 @@ export declare class CommandBus<CommandBase extends ICommand = ICommand> extends
      * @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;
-    protected registerHandler(handler: CommandHandlerType): void;
+    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>;
+    bind<T extends CommandBase>(handler: InstanceWrapper<ICommandHandler<T>>, id: string): void;
+    register(handlers?: InstanceWrapper<ICommandHandler<CommandBase>>[]): void;
+    protected registerHandler(handler: InstanceWrapper<ICommandHandler<CommandBase>>): void;
     private getCommandId;
     private getCommandName;
     private reflectCommandId;

package/dist/command-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 CommandBus_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandBus = 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 command_not_found_exception_1 = require("./exceptions/command-not-found.exception");
 const default_command_pubsub_1 = require("./helpers/default-command-pubsub");
 const index_1 = require("./index");
+const async_context_1 = require("./scopes/async.context");
 const observable_bus_1 = require("./utils/observable-bus");
-let CommandBus = class CommandBus extends observable_bus_1.ObservableBus {
-    constructor(moduleRef) {
+let CommandBus = CommandBus_1 = class CommandBus extends observable_bus_1.ObservableBus {
+    constructor(moduleRef, options) {
         super();
         this.moduleRef = moduleRef;
+        this.options = options;
+        this.logger = new common_1.Logger(CommandBus_1.name);
         this.handlers = new Map();
-        this.useDefaultPublisher();
+        if (this.options?.commandPublisher) {
+            this._publisher = this.options.commandPublisher;
+        }
+        else {
+            this.useDefaultPublisher();
+        }
     }
     /**
      * Returns the publisher.
@@ -43,38 +56,59 @@ let CommandBus = class CommandBus extends observable_bus_1.ObservableBus {
     /**
      * 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(command) {
+    execute(command, context) {
         const commandId = this.getCommandId(command);
-        const handler = this.handlers.get(commandId);
-        if (!handler) {
+        const executeFn = this.handlers.get(commandId);
+        if (!executeFn) {
             const commandName = this.getCommandName(command);
             throw new command_not_found_exception_1.CommandHandlerNotFoundException(commandName);
         }
         this._publisher.publish(command);
-        return handler.execute(command);
+        return executeFn(command, context);
     }
     bind(handler, id) {
-        this.handlers.set(id, handler);
+        if (handler.isDependencyTreeStatic()) {
+            const instance = handler.instance;
+            if (!instance.execute) {
+                throw new index_1.InvalidCommandHandlerException();
+            }
+            this.handlers.set(id, (command) => instance.execute(command));
+            return;
+        }
+        this.handlers.set(id, async (command, context) => {
+            context ??= async_context_1.AsyncContext.of(command) ?? new async_context_1.AsyncContext();
+            if (!async_context_1.AsyncContext.isAttached(context)) {
+                // Commands returned by sagas may already have an async context set
+                // and a corresponding request provider registered.
+                this.moduleRef.registerRequestByContextId(context, context.id);
+                context.attachTo(command);
+            }
+            const instance = await this.moduleRef.resolve(handler.metatype, context.id, {
+                strict: false,
+            });
+            return instance.execute(command);
+        });
     }
     register(handlers = []) {
         handlers.forEach((handler) => this.registerHandler(handler));
     }
     registerHandler(handler) {
-        const instance = this.moduleRef.get(handler, { strict: false });
-        if (!instance) {
-            return;
-        }
-        const target = this.reflectCommandId(handler);
+        const typeRef = handler.metatype;
+        const target = this.reflectCommandId(typeRef);
         if (!target) {
             throw new index_1.InvalidCommandHandlerException();
         }
-        this.bind(instance, target);
+        if (this.handlers.has(target)) {
+            this.logger.warn(`Command handler [${typeRef.name}] is already registered. Overriding previously registered handler.`);
+        }
+        this.bind(handler, target);
     }
     getCommandId(command) {
         const { constructor: commandType } = Object.getPrototypeOf(command);
-        const commandMetadata = Reflect.getMetadata(constants_1.COMMAND_METADATA, commandType);
+        const commandMetadata = Reflect.getMetadata(constants_2.COMMAND_METADATA, commandType);
         if (!commandMetadata) {
             throw new command_not_found_exception_1.CommandHandlerNotFoundException(commandType.name);
         }
@@ -85,16 +119,18 @@ let CommandBus = class CommandBus extends observable_bus_1.ObservableBus {
         return constructor.name;
     }
     reflectCommandId(handler) {
-        const command = Reflect.getMetadata(constants_1.COMMAND_HANDLER_METADATA, handler);
-        const commandMetadata = Reflect.getMetadata(constants_1.COMMAND_METADATA, command);
+        const command = Reflect.getMetadata(constants_2.COMMAND_HANDLER_METADATA, handler);
+        const commandMetadata = Reflect.getMetadata(constants_2.COMMAND_METADATA, command);
         return commandMetadata.id;
     }
     useDefaultPublisher() {
         this._publisher = new default_command_pubsub_1.DefaultCommandPubSub(this.subject$);
     }
 };
-CommandBus = __decorate([
+exports.CommandBus = CommandBus;
+exports.CommandBus = CommandBus = CommandBus_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])
 ], CommandBus);
-exports.CommandBus = CommandBus;

package/dist/constants.d.ts

@@ -1 +1 @@
-export declare const CQRS_MODULE_OPTIONS = 'CQRS_MODULE_OPTIONS';
+export declare const CQRS_MODULE_OPTIONS = "CQRS_MODULE_OPTIONS";

package/dist/constants.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CQRS_MODULE_OPTIONS = void 0;
 exports.CQRS_MODULE_OPTIONS = 'CQRS_MODULE_OPTIONS';

package/dist/cqrs.module.d.ts

@@ -1,7 +1,7 @@
 import { DynamicModule, OnApplicationBootstrap } from '@nestjs/common';
 import { CommandBus } from './command-bus';
 import { EventBus } from './event-bus';
-import { IEvent } from './interfaces';
+import { CqrsModuleOptions, IEvent } from './interfaces';
 import { QueryBus } from './query-bus';
 import { ExplorerService } from './services/explorer.service';
 export declare class CqrsModule<EventBase extends IEvent = IEvent> implements OnApplicationBootstrap {
@@ -10,10 +10,11 @@ export declare class CqrsModule<EventBase extends IEvent = IEvent> implements On
     private readonly commandBus;
     private readonly queryBus;
     /**
-     * Registers the CQRS Module globally.
-     * @returns DynamicModule
+     * Registers CQRS module globally.
+     * @param options CQRS module options.
+     * @returns A dynamic module.
      */
-    static forRoot(): DynamicModule;
+    static forRoot(options?: CqrsModuleOptions): DynamicModule;
     constructor(explorerService: ExplorerService<EventBase>, eventBus: EventBus<EventBase>, commandBus: CommandBus, queryBus: QueryBus);
     onApplicationBootstrap(): void;
 }

package/dist/cqrs.module.js

@@ -13,37 +13,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CqrsModule = void 0;
 const common_1 = require("@nestjs/common");
 const command_bus_1 = require("./command-bus");
+const constants_1 = require("./constants");
 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");
+const aggregate_root_storage_1 = require("./storages/aggregate-root.storage");
 let CqrsModule = CqrsModule_1 = class CqrsModule {
-    constructor(explorerService, eventBus, commandBus, queryBus) {
-        this.explorerService = explorerService;
-        this.eventBus = eventBus;
-        this.commandBus = commandBus;
-        this.queryBus = queryBus;
-    }
     /**
-     * Registers the CQRS Module globally.
-     * @returns DynamicModule
+     * Registers CQRS module globally.
+     * @param options CQRS module options.
+     * @returns A dynamic module.
      */
-    static forRoot() {
+    static forRoot(options) {
         return {
             module: CqrsModule_1,
+            providers: [
+                {
+                    provide: constants_1.CQRS_MODULE_OPTIONS,
+                    useValue: options ?? {},
+                },
+            ],
             global: true,
         };
     }
+    constructor(explorerService, eventBus, commandBus, queryBus) {
+        this.explorerService = explorerService;
+        this.eventBus = eventBus;
+        this.commandBus = commandBus;
+        this.queryBus = queryBus;
+    }
     onApplicationBootstrap() {
         const { events, queries, sagas, commands } = this.explorerService.explore();
         this.eventBus.register(events);
         this.commandBus.register(commands);
         this.queryBus.register(queries);
         this.eventBus.registerSagas(sagas);
+        aggregate_root_storage_1.AggregateRootStorage.mergeContext(this.eventBus);
     }
 };
-CqrsModule = CqrsModule_1 = __decorate([
+exports.CqrsModule = CqrsModule;
+exports.CqrsModule = CqrsModule = CqrsModule_1 = __decorate([
     (0, common_1.Module)({
         providers: [
             command_bus_1.CommandBus,
@@ -66,4 +77,3 @@ CqrsModule = CqrsModule_1 = __decorate([
         command_bus_1.CommandBus,
         query_bus_1.QueryBus])
 ], CqrsModule);
-exports.CqrsModule = CqrsModule;

package/dist/decorators/command-handler.decorator.d.ts

@@ -1,3 +1,4 @@
+import { InjectableOptions } from '@nestjs/common';
 import 'reflect-metadata';
 import { ICommand } from '../index';
 /**
@@ -7,7 +8,8 @@ import { ICommand } from '../index';
  * The decorated class must implement the `ICommandHandler` interface.
  *
  * @param command command *type* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#commands
  */
-export declare const CommandHandler: (command: ICommand | (new (...args: any[]) => ICommand)) => ClassDecorator;
+export declare const CommandHandler: (command: ICommand | (new (...args: any[]) => ICommand), options?: InjectableOptions) => ClassDecorator;

package/dist/decorators/command-handler.decorator.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandler = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
 require("reflect-metadata");
 const constants_1 = require("./constants");
-const uuid_1 = require("uuid");
 /**
  * Decorator that marks a class as a Nest command handler. A command handler
  * handles commands (actions) executed by your application code.
@@ -11,15 +12,19 @@ const uuid_1 = require("uuid");
  * The decorated class must implement the `ICommandHandler` interface.
  *
  * @param command command *type* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#commands
  */
-const CommandHandler = (command) => {
+const CommandHandler = (command, options) => {
     return (target) => {
         if (!Reflect.hasOwnMetadata(constants_1.COMMAND_METADATA, command)) {
-            Reflect.defineMetadata(constants_1.COMMAND_METADATA, { id: (0, uuid_1.v4)() }, command);
+            Reflect.defineMetadata(constants_1.COMMAND_METADATA, { id: (0, crypto_1.randomUUID)() }, command);
         }
         Reflect.defineMetadata(constants_1.COMMAND_HANDLER_METADATA, command, target);
+        if (options) {
+            (0, common_1.Injectable)(options)(target);
+        }
     };
 };
 exports.CommandHandler = CommandHandler;

package/dist/decorators/events-handler.decorator.d.ts

@@ -1,3 +1,4 @@
+import { InjectableOptions } from '@nestjs/common';
 import 'reflect-metadata';
 import { IEvent } from '../index';
 /**
@@ -7,7 +8,8 @@ import { IEvent } from '../index';
  * The decorated class must implement the `IEventHandler` interface.
  *
  * @param events one or more event *types* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#events
  */
-export declare const EventsHandler: (...events: (IEvent | (new (...args: any[]) => IEvent))[]) => ClassDecorator;
+export declare const EventsHandler: (...events: (IEvent | (new (...args: any[]) => IEvent) | InjectableOptions)[]) => ClassDecorator;

package/dist/decorators/events-handler.decorator.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventsHandler = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
 require("reflect-metadata");
 const constants_1 = require("./constants");
-const uuid_1 = require("uuid");
 /**
  * Decorator that marks a class as a Nest event handler. An event handler
  * handles events executed by your application code.
@@ -11,14 +12,20 @@ const uuid_1 = require("uuid");
  * The decorated class must implement the `IEventHandler` interface.
  *
  * @param events one or more event *types* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#events
  */
 const EventsHandler = (...events) => {
     return (target) => {
+        const last = events[events.length - 1];
+        if (typeof last !== 'function' && 'scope' in last) {
+            (0, common_1.Injectable)(last)(target);
+            events.pop();
+        }
         events.forEach((event) => {
             if (!Reflect.hasOwnMetadata(constants_1.EVENT_METADATA, event)) {
-                Reflect.defineMetadata(constants_1.EVENT_METADATA, { id: (0, uuid_1.v4)() }, event);
+                Reflect.defineMetadata(constants_1.EVENT_METADATA, { id: (0, crypto_1.randomUUID)() }, event);
             }
         });
         Reflect.defineMetadata(constants_1.EVENTS_HANDLER_METADATA, events, target);

package/dist/decorators/index.d.ts

@@ -2,3 +2,4 @@ export * from './command-handler.decorator';
 export * from './events-handler.decorator';
 export * from './query-handler.decorator';
 export * from './saga.decorator';
+export * from './publishable.decorator';

package/dist/decorators/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,3 +18,4 @@ __exportStar(require("./command-handler.decorator"), exports);
 __exportStar(require("./events-handler.decorator"), exports);
 __exportStar(require("./query-handler.decorator"), exports);
 __exportStar(require("./saga.decorator"), exports);
+__exportStar(require("./publishable.decorator"), exports);

package/dist/decorators/publishable.decorator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Merges event publisher with the decorated class.
+ * Implements the `publish` and `publishAll` methods in a similar way to {@link EventPublisher#mergeClassContext}.
+ */
+export declare function Publishable(): ClassDecorator;

package/dist/decorators/publishable.decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publishable = Publishable;
+const aggregate_root_storage_1 = require("../storages/aggregate-root.storage");
+/**
+ * Merges event publisher with the decorated class.
+ * Implements the `publish` and `publishAll` methods in a similar way to {@link EventPublisher#mergeClassContext}.
+ */
+function Publishable() {
+    return (target) => {
+        aggregate_root_storage_1.AggregateRootStorage.add(target);
+    };
+}

package/dist/decorators/query-handler.decorator.d.ts

@@ -1,3 +1,4 @@
+import { InjectableOptions } from '@nestjs/common';
 import 'reflect-metadata';
 import { IQuery } from '../interfaces';
 /**
@@ -7,7 +8,8 @@ import { IQuery } from '../interfaces';
  * The decorated class must implement the `IQueryHandler` interface.
  *
  * @param query query *type* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#queries
  */
-export declare const QueryHandler: (query: IQuery) => ClassDecorator;
+export declare const QueryHandler: (query: IQuery, options?: InjectableOptions) => ClassDecorator;

package/dist/decorators/query-handler.decorator.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryHandler = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
 require("reflect-metadata");
 const constants_1 = require("./constants");
-const uuid_1 = require("uuid");
 /**
  * Decorator that marks a class as a Nest query handler. A query handler
  * handles queries executed by your application code.
@@ -11,15 +12,19 @@ const uuid_1 = require("uuid");
  * The decorated class must implement the `IQueryHandler` interface.
  *
  * @param query query *type* to be handled by this handler.
+ * @param options injectable options passed on to the "@Injectable" decorator.
  *
  * @see https://docs.nestjs.com/recipes/cqrs#queries
  */
-const QueryHandler = (query) => {
+const QueryHandler = (query, options) => {
     return (target) => {
         if (!Reflect.hasOwnMetadata(constants_1.QUERY_METADATA, query)) {
-            Reflect.defineMetadata(constants_1.QUERY_METADATA, { id: (0, uuid_1.v4)() }, query);
+            Reflect.defineMetadata(constants_1.QUERY_METADATA, { id: (0, crypto_1.randomUUID)() }, query);
         }
         Reflect.defineMetadata(constants_1.QUERY_HANDLER_METADATA, query, target);
+        if (options) {
+            (0, common_1.Injectable)(options)(target);
+        }
     };
 };
 exports.QueryHandler = QueryHandler;