@nestjs/cqrs 11.0.3 → 12.1.0

package/test/e2e/sync-event-handlers-app.spec.ts

@@ -0,0 +1,123 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { MockInstance, vi } from 'vitest';
+import { AsyncHandlersAppModule } from '../src/sync-event-handlers/async-handlers-app.module.js';
+import { EventBus } from '../../src/event-bus.js';
+import { HeroKilledDragon2SlowHandler } from '../src/sync-event-handlers/events/handlers/hero-killed-dragon2-slow.handler.js';
+import { HeroKilledDragonSlowHandler } from '../src/sync-event-handlers/events/handlers/hero-killed-dragon-slow.handler.js';
+import { HeroFoundItemSlowHandler } from '../src/sync-event-handlers/events/handlers/hero-found-item-slow.handler.js';
+import { SyncHandlersAppModule } from '../src/sync-event-handlers/sync-handlers-app.module.js';
+import { HeroFoundItemEvent } from '../src/heroes/events/impl/hero-found-item.event.js';
+import { HeroKilledDragonEvent } from '../src/heroes/events/impl/hero-killed-dragon.event.js';
+
+describe('Sync event handlers', () => {
+  let moduleRef: TestingModule;
+  let eventBus: EventBus;
+  let heroFoundItemHandler: HeroFoundItemSlowHandler;
+  let heroFoundItemEnded: MockInstance;
+  let heroKilledDragonHandler: HeroKilledDragonSlowHandler;
+  let heroKilledDragonEnded: MockInstance;
+  let heroKilledDragon2Handler: HeroKilledDragon2SlowHandler;
+  let heroKilledDragon2Ended: MockInstance;
+
+  beforeEach(() => {
+    heroFoundItemEnded.mockClear();
+    heroKilledDragonEnded.mockClear();
+    heroKilledDragon2Ended.mockClear();
+  });
+
+  describe('when event handlers are fully asynchronous', () => {
+    beforeAll(async () => {
+      moduleRef = await Test.createTestingModule({
+        imports: [AsyncHandlersAppModule],
+      }).compile();
+
+      await moduleRef.init();
+      eventBus = moduleRef.get(EventBus);
+      heroFoundItemHandler = moduleRef.get(HeroFoundItemSlowHandler);
+      heroKilledDragonHandler = moduleRef.get(HeroKilledDragonSlowHandler);
+      heroKilledDragon2Handler = moduleRef.get(HeroKilledDragon2SlowHandler);
+      heroFoundItemEnded = vi.spyOn(heroFoundItemHandler, 'end');
+      heroKilledDragonEnded = vi.spyOn(heroKilledDragonHandler, 'end');
+      heroKilledDragon2Ended = vi.spyOn(heroKilledDragon2Handler, 'end');
+    });
+
+    describe('when "HeroFoundItemEvent" event is published', () => {
+      it('should wait for the event handlers to complete', async () => {
+        const event = new HeroFoundItemEvent('hero1', 'item1');
+
+        await eventBus.publish(event);
+
+        expect(heroFoundItemEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragonEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragon2Ended).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when "HeroKilledDragonEvent" event is published', () => {
+      it('should wait for the event handlers to complete', async () => {
+        const event = new HeroKilledDragonEvent('hero1', 'dragon1');
+
+        await eventBus.publish(event);
+
+        expect(heroFoundItemEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragonEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragon2Ended).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('when event handlers are synchronous', () => {
+    beforeAll(async () => {
+      moduleRef = await Test.createTestingModule({
+        imports: [SyncHandlersAppModule],
+      }).compile();
+
+      await moduleRef.init();
+      eventBus = moduleRef.get(EventBus);
+      heroFoundItemHandler = moduleRef.get(HeroFoundItemSlowHandler);
+      heroKilledDragonHandler = moduleRef.get(HeroKilledDragonSlowHandler);
+      heroKilledDragon2Handler = moduleRef.get(HeroKilledDragon2SlowHandler);
+      heroFoundItemEnded = vi.spyOn(heroFoundItemHandler, 'end');
+      heroKilledDragonEnded = vi.spyOn(heroKilledDragonHandler, 'end');
+      heroKilledDragon2Ended = vi.spyOn(heroKilledDragon2Handler, 'end');
+    });
+
+    describe('when "HeroFoundItemEvent" event is published', () => {
+      it('should wait for the event handlers to complete', async () => {
+        const event = new HeroFoundItemEvent('hero1', 'item1');
+
+        await eventBus.publish(event);
+
+        expect(heroFoundItemEnded).toHaveBeenCalledTimes(1);
+        expect(heroKilledDragonEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragon2Ended).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when "HeroKilledDragonEvent" event is published', () => {
+      it('should wait for the event handlers to complete', async () => {
+        const event = new HeroKilledDragonEvent('hero1', 'dragon1');
+
+        await eventBus.publish(event);
+
+        expect(heroFoundItemEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragonEnded).toHaveBeenCalledTimes(1);
+        expect(heroKilledDragon2Ended).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe('when an unknown event is published', () => {
+      it('should return directly', async () => {
+        await eventBus.publish({ id: 'unknown event' });
+
+        expect(heroFoundItemEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragonEnded).not.toHaveBeenCalled();
+        expect(heroKilledDragon2Ended).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  afterAll(async () => {
+    await moduleRef.close();
+  });
+});

package/test/e2e/unhandled-exceptions.spec.ts

@@ -1,9 +1,10 @@
+import { Logger } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { take } from 'rxjs';
-import { CommandBus, UnhandledExceptionBus } from '../../src';
-import { AppModule } from '../src/app.module';
-import { UnhandledExceptionCommand } from '../src/errors/commands/unhandled-exception.command';
-import { UnhandledExceptionEvent } from '../src/errors/events/unhandled-exception.event';
+import { CommandBus, UnhandledExceptionBus } from '../../src/index.js';
+import { AppModule } from '../src/app.module.js';
+import { UnhandledExceptionCommand } from '../src/errors/commands/unhandled-exception.command.js';
+import { UnhandledExceptionEvent } from '../src/errors/events/unhandled-exception.event.js';
 
 describe('Unhandled exceptions', () => {
   let moduleRef: TestingModule;
@@ -36,34 +37,68 @@ describe('Unhandled exceptions', () => {
   });
 
   describe('when exception is thrown from event handler', () => {
-    it('should forward exception to UnhandledExceptionBus', (done) => {
+    it('should forward exception to UnhandledExceptionBus', async () => {
       const command = new UnhandledExceptionCommand('event');
       const commandBus = moduleRef.get(CommandBus);
 
-      unhandledExceptionBus.pipe(take(1)).subscribe((exceptionInfo) => {
-        expect(exceptionInfo.exception).toEqual(
-          new Error(`Unhandled exception in ${command.failAt}`),
-        );
-        expect(exceptionInfo.cause).toBeInstanceOf(UnhandledExceptionEvent);
-        done();
+      const exceptionPromise = new Promise<void>((resolve, reject) => {
+        unhandledExceptionBus.pipe(take(1)).subscribe((exceptionInfo) => {
+          try {
+            expect(exceptionInfo.exception).toEqual(
+              new Error(`Unhandled exception in ${command.failAt}`),
+            );
+            expect(exceptionInfo.cause).toBeInstanceOf(UnhandledExceptionEvent);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+        commandBus.execute(command).catch((err) => reject(err));
       });
-      commandBus.execute(command).catch((err) => done(err));
+
+      await exceptionPromise;
+    });
+
+    it('should log the event handler class name', async () => {
+      const loggerSpy = vi.spyOn(Logger.prototype, 'error');
+      const command = new UnhandledExceptionCommand('event');
+      const commandBus = moduleRef.get(CommandBus);
+
+      const exceptionPromise = new Promise<void>((resolve) => {
+        unhandledExceptionBus.pipe(take(1)).subscribe(() => resolve());
+      });
+      await commandBus.execute(command);
+      await exceptionPromise;
+
+      expect(loggerSpy).toHaveBeenCalledWith(
+        '"UnhandledExceptionEventHandler" has thrown an unhandled exception.',
+        new Error(`Unhandled exception in ${command.failAt}`),
+      );
+      loggerSpy.mockRestore();
     });
   });
 
   describe('when exception is thrown from saga', () => {
-    it('should forward exception to UnhandledExceptionBus', (done) => {
+    it('should forward exception to UnhandledExceptionBus', async () => {
       const command = new UnhandledExceptionCommand('saga');
       const commandBus = moduleRef.get(CommandBus);
 
-      unhandledExceptionBus.pipe(take(1)).subscribe((exceptionInfo) => {
-        expect(exceptionInfo.exception).toEqual(
-          new Error(`Unhandled exception in ${command.failAt}`),
-        );
-        expect(exceptionInfo.cause).toEqual('onError');
-        done();
+      const exceptionPromise = new Promise<void>((resolve, reject) => {
+        unhandledExceptionBus.pipe(take(1)).subscribe((exceptionInfo) => {
+          try {
+            expect(exceptionInfo.exception).toEqual(
+              new Error(`Unhandled exception in ${command.failAt}`),
+            );
+            expect(exceptionInfo.cause).toEqual('onError');
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+        commandBus.execute(command).catch((err) => reject(err));
       });
-      commandBus.execute(command).catch((err) => done(err));
+
+      await exceptionPromise;
     });
   });
 

package/tsconfig.build.json

@@ -2,10 +2,11 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "types": ["node"]
   },
   "include": [
-    "src/**/*",
+    "src/**/*"
   ],
   "exclude": [
     "node_modules",

package/vitest.config.e2e.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  oxc: {
+    transform: { decorators: { legacy: true, emitDecoratorMetadata: true } },
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['test/e2e/**/*.spec.ts'],
+    fileParallelism: false,
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  oxc: {
+    transform: { decorators: { legacy: true, emitDecoratorMetadata: true } },
+  },
+  test: { globals: true, environment: 'node', include: ['src/**/*.spec.ts'] },
+});

package/dist/exceptions/invalid-module-ref.exception.d.ts

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

package/dist/exceptions/invalid-module-ref.exception.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class InvalidModuleRefException extends Error {
-    constructor() {
-        super(`Invalid ModuleRef exception. Remember to set module reference "setModuleRef()".`);
-    }
-}
-exports.InvalidModuleRefException = InvalidModuleRefException;

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

@@ -1,9 +0,0 @@
-import { IEvent } from '../interfaces';
-import { Type } from '@nestjs/common';
-/**
- * Null if the published class is not connected to any handler
- * @param event
- * @returns
- */
-export declare const defaultGetEventId: <EventBase extends IEvent = IEvent>(event: EventBase) => string;
-export declare const defaultReflectEventId: <EventBase extends Type<IEvent> = Type<IEvent>>(event: EventBase) => string;

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

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultReflectEventId = exports.defaultGetEventId = void 0;
-const constants_1 = require("../decorators/constants");
-/**
- * Null if the published class is not connected to any handler
- * @param event
- * @returns
- */
-const defaultGetEventId = (event) => {
-    const { constructor } = Object.getPrototypeOf(event);
-    return Reflect.getMetadata(constants_1.EVENT_METADATA, constructor)?.id ?? null;
-};
-exports.defaultGetEventId = defaultGetEventId;
-const defaultReflectEventId = (event) => {
-    return Reflect.getMetadata(constants_1.EVENT_METADATA, event).id;
-};
-exports.defaultReflectEventId = defaultReflectEventId;

package/dist/helpers/default-get-event-name.d.ts

@@ -1,2 +0,0 @@
-import { IEvent } from '../interfaces';
-export declare const defaultGetEventName: <EventBase extends IEvent = IEvent>(event: EventBase) => string;

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

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultGetEventName = void 0;
-const defaultGetEventName = (event) => {
-    const { constructor } = Object.getPrototypeOf(event);
-    return constructor.name;
-};
-exports.defaultGetEventName = defaultGetEventName;

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

@@ -1,10 +0,0 @@
-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';
-export interface CqrsOptions {
-    events?: Type<IEventHandler>[];
-    queries?: Type<IQueryHandler>[];
-    commands?: Type<ICommandHandler>[];
-    sagas?: Type<any>[];
-}

package/dist/interfaces/cqrs-options.interface.js

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

package/dist/interfaces/event-observable.interface.d.ts

@@ -1,4 +0,0 @@
-import { Observable } from 'rxjs';
-export interface EventObservable<T> {
-  ofType(...events: any[]): Observable<T>;
-}

package/dist/interfaces/event-observable.interface.js

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

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

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-import { ICommand } from '../index';
-export declare const CommandHandler: (command: ICommand) => ClassDecorator;

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

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const constants_1 = require("./constants");
-exports.CommandHandler = (command) => {
-    return (target) => {
-        Reflect.defineMetadata(constants_1.COMMAND_HANDLER_METADATA, command, target);
-    };
-};

package/dist/utils/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const COMMAND_HANDLER_METADATA = '__commandHandler__';
-export declare const EVENTS_HANDLER_METADATA = '__eventsHandler';

package/dist/utils/constants.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMAND_HANDLER_METADATA = '__commandHandler__';
-exports.EVENTS_HANDLER_METADATA = '__eventsHandler';

package/dist/utils/default-pubsub.d.ts

@@ -1,9 +0,0 @@
-import { Subject } from 'rxjs';
-import { IEvent } from '../interfaces';
-import { IEventPublisher } from '../interfaces/events/event-publisher.interface';
-import { IMessageSource } from '../interfaces/events/message-source.interface';
-export declare class DefaultPubSub implements IEventPublisher, IMessageSource {
-  private subject$;
-  publish<T extends IEvent>(event: T): void;
-  bridgeEventsTo<T extends IEvent>(subject: Subject<T>): void;
-}

package/dist/utils/default-pubsub.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class DefaultPubSub {
-    publish(event) {
-        if (!this.subject$) {
-            throw new Error('Invalid underlying subject (call bridgeEventsTo())');
-        }
-        this.subject$.next(event);
-    }
-    bridgeEventsTo(subject) {
-        this.subject$ = subject;
-    }
-}
-exports.DefaultPubSub = DefaultPubSub;

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

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-import { IEvent } from '../index';
-export declare const EventsHandler: (...events: IEvent[]) => ClassDecorator;

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

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const constants_1 = require("./constants");
-exports.EventsHandler = (...events) => {
-    return (target) => {
-        Reflect.defineMetadata(constants_1.EVENTS_HANDLER_METADATA, events, target);
-    };
-};

package/eslint.config.mjs

@@ -1,42 +0,0 @@
-// @ts-check
-import eslint from '@eslint/js';
-import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
-import globals from 'globals';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-  {
-    ignores: ['tests/**'],
-  },
-  eslint.configs.recommended,
-  ...tseslint.configs.recommendedTypeChecked,
-  eslintPluginPrettierRecommended,
-  {
-    languageOptions: {
-      globals: {
-        ...globals.node,
-        ...globals.jest,
-      },
-      ecmaVersion: 5,
-      sourceType: 'module',
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-  },
-  {
-    rules: {
-      '@typescript-eslint/no-explicit-any': 'off',
-      '@typescript-eslint/no-unsafe-assignment': 'off',
-      '@typescript-eslint/no-unsafe-call': 'off',
-      '@typescript-eslint/no-unsafe-member-access': 'off',
-      '@typescript-eslint/no-unsafe-function-type': 'off',
-      '@typescript-eslint/no-unsafe-argument': 'off',
-      '@typescript-eslint/no-unsafe-return': 'off',
-      '@typescript-eslint/require-await': 'warn',
-      '@typescript-eslint/no-unused-expressions': 'warn',
-      '@typescript-eslint/no-empty-object-type': 'off',
-    },
-  },
-);

package/index.d.ts

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

package/index.js

@@ -1,6 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-exports.__esModule = true;
-__export(require("./dist"));

package/jest.config.js

@@ -1,9 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  rootDir: '.',
-  testMatch: ['<rootDir>/src/**/*.spec.ts'],
-  transform: {
-    '^.+\\.ts$': 'ts-jest'
-  },
-};

package/test/jest-e2e.json

@@ -1,9 +0,0 @@
-{
-  "moduleFileExtensions": ["js", "json", "ts"],
-  "rootDir": ".",
-  "testEnvironment": "node",
-  "testRegex": ".spec.ts$",
-  "transform": {
-    "^.+\\.(t|j)s$": ["ts-jest", { "tsconfig": "./test/tsconfig.json" }]
-  }
-}