@nestjs/cqrs 11.0.3 → 12.1.0

package/dist/unhandled-exception-bus.js

@@ -1,4 +1,3 @@
-"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -11,19 +10,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnhandledExceptionBus = void 0;
-const common_1 = require("@nestjs/common");
-require("reflect-metadata");
-const rxjs_1 = require("rxjs");
-const constants_1 = require("./constants");
-const default_unhandled_exception_pubsub_1 = require("./helpers/default-unhandled-exception-pubsub");
-const observable_bus_1 = require("./utils/observable-bus");
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import 'reflect-metadata';
+import { filter } from 'rxjs';
+import { CQRS_MODULE_OPTIONS } from './constants.js';
+import { DefaultUnhandledExceptionPubSub } from './helpers/default-unhandled-exception-pubsub.js';
+import { ObservableBus } from './utils/observable-bus.js';
 /**
  * A bus that publishes unhandled exceptions.
  * @template Cause The type of the cause of the exception.
  */
-let UnhandledExceptionBus = class UnhandledExceptionBus extends observable_bus_1.ObservableBus {
+let UnhandledExceptionBus = class UnhandledExceptionBus extends ObservableBus {
     constructor(options) {
         super();
         this.options = options;
@@ -44,7 +41,7 @@ let UnhandledExceptionBus = class UnhandledExceptionBus extends observable_bus_1
      */
     static ofType(...types) {
         const isInstanceOf = (exceptionInfo) => !!types.find((classType) => exceptionInfo.exception instanceof classType);
-        return (source) => source.pipe((0, rxjs_1.filter)(isInstanceOf));
+        return (source) => source.pipe(filter(isInstanceOf));
     }
     /**
      * Gets the publisher of the bus.
@@ -66,13 +63,13 @@ let UnhandledExceptionBus = class UnhandledExceptionBus extends observable_bus_1
         return this._publisher.publish(info);
     }
     useDefaultPublisher() {
-        this._publisher = new default_unhandled_exception_pubsub_1.DefaultUnhandledExceptionPubSub(this.subject$);
+        this._publisher = new DefaultUnhandledExceptionPubSub(this.subject$);
     }
 };
-exports.UnhandledExceptionBus = UnhandledExceptionBus;
-exports.UnhandledExceptionBus = UnhandledExceptionBus = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Optional)()),
-    __param(0, (0, common_1.Inject)(constants_1.CQRS_MODULE_OPTIONS)),
+UnhandledExceptionBus = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(CQRS_MODULE_OPTIONS)),
     __metadata("design:paramtypes", [Object])
 ], UnhandledExceptionBus);
+export { UnhandledExceptionBus };

package/dist/utils/index.d.ts

@@ -1 +1 @@
-export * from './observable-bus';
+export * from './observable-bus.js';

package/dist/utils/index.js

@@ -1,17 +1 @@
-"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("./observable-bus"), exports);
+export * from './observable-bus.js';

package/dist/utils/observable-bus.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableBus = void 0;
-const rxjs_1 = require("rxjs");
-class ObservableBus extends rxjs_1.Observable {
+import { Observable, Subject } from 'rxjs';
+export class ObservableBus extends Observable {
     constructor() {
         super();
-        this._subject$ = new rxjs_1.Subject();
+        this._subject$ = new Subject();
         this.source = this._subject$;
     }
     get subject$() {
         return this._subject$;
     }
 }
-exports.ObservableBus = ObservableBus;

package/package.json

@@ -1,14 +1,29 @@
 {
   "name": "@nestjs/cqrs",
-  "version": "11.0.3",
+  "version": "12.1.0",
   "description": "A lightweight CQRS module for Nest framework (node.js)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
   "license": "MIT",
   "url": "https://github.com/nestjs/cqrs#readme",
   "scripts": {
-    "test": "jest",
+    "test": "vitest run",
     "build": "tsc -p tsconfig.build.json",
     "format": "prettier --write \"**/*.ts\"",
-    "lint": "eslint \"src/**/*.ts\" --fix",
+    "lint": "oxlint src/",
     "prepublish:next": "npm run build",
     "publish:next": "npm publish --access public --tag next",
     "prepublish:npm": "npm run build",
@@ -16,36 +31,29 @@
     "prerelease": "npm run build",
     "release": "release-it",
     "prepare": "husky",
-    "test:e2e": "jest --config ./test/jest-e2e.json --runInBand"
+    "test:e2e": "vitest run --config vitest.config.e2e.ts"
   },
   "devDependencies": {
-    "@commitlint/cli": "19.8.0",
-    "@commitlint/config-angular": "19.8.0",
-    "@eslint/eslintrc": "3.3.1",
-    "@eslint/js": "9.23.0",
-    "@nestjs/common": "11.0.12",
-    "@nestjs/core": "11.0.12",
-    "@nestjs/testing": "11.0.12",
-    "@types/jest": "29.5.14",
-    "@types/node": "22.13.11",
-    "eslint": "9.23.0",
-    "eslint-config-prettier": "10.1.1",
-    "eslint-plugin-prettier": "5.2.4",
-    "globals": "16.0.0",
+    "@commitlint/cli": "21.2.3",
+    "@commitlint/config-angular": "21.2.3",
+    "@nestjs/common": "12.1.1",
+    "@nestjs/core": "12.1.1",
+    "@nestjs/testing": "12.1.1",
+    "@types/node": "24.19.0",
     "husky": "9.1.7",
-    "jest": "29.7.0",
-    "lint-staged": "15.5.0",
-    "prettier": "3.5.3",
+    "lint-staged": "17.6.0",
+    "oxlint": "1.86.0",
+    "prettier": "3.9.9",
     "reflect-metadata": "0.2.2",
-    "release-it": "18.1.2",
+    "release-it": "21.1.0",
     "rxjs": "7.8.2",
-    "ts-jest": "29.2.6",
-    "typescript": "5.8.2",
-    "typescript-eslint": "8.27.0"
+    "typescript": "7.0.2",
+    "vite": "8.3.1",
+    "vitest": "4.1.11"
   },
   "peerDependencies": {
-    "@nestjs/common": "^10.0.0 || ^11.0.0",
-    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.2.0"
   },

package/test/e2e/aggregate-commit-context.spec.ts

@@ -0,0 +1,243 @@
+import { Inject, Injectable, Module, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Test, TestingModule } from '@nestjs/testing';
+import { setImmediate } from 'timers/promises';
+import {
+  AggregateRoot,
+  AsyncContext,
+  CommandBus,
+  CommandHandler,
+  CqrsModule,
+  EventBus,
+  EventPublisher,
+  EventsHandler,
+  ICommandHandler,
+  IEvent,
+  IEventHandler,
+  IEventPublisher,
+  Publishable,
+} from '../../src/index.js';
+import { waitImmediate } from '../utils/wait-immediate.js';
+
+interface Transaction {
+  id: string;
+  fail?: Error;
+}
+
+class OrderPlacedEvent implements IEvent {
+  constructor(public readonly orderId: string) {}
+}
+
+class Order extends AggregateRoot {
+  constructor(public readonly id: string) {
+    super();
+  }
+
+  place() {
+    this.apply(new OrderPlacedEvent(this.id));
+  }
+}
+
+@Publishable()
+class PublishableOrder extends Order {}
+
+class PlaceOrderCommand {
+  constructor(
+    public readonly orderId: string,
+    public readonly transaction?: Transaction,
+    public readonly publishable = false,
+  ) {}
+}
+
+class ScopedPlaceOrderCommand {
+  constructor(
+    public readonly orderId: string,
+    public readonly transaction: Transaction,
+  ) {}
+}
+
+/**
+ * Stands in for a publisher that writes events through the dispatcher context's transaction
+ * (an outbox, or durable workflows) before it hands them to the in-memory handlers.
+ */
+@Injectable()
+class TransactionalEventPublisher implements IEventPublisher {
+  readonly written: Array<{
+    orderIds: string[];
+    context: unknown;
+    asyncContext?: AsyncContext;
+  }> = [];
+  private readonly inner: IEventPublisher;
+
+  constructor(eventBus: EventBus) {
+    this.inner = eventBus.publisher;
+    eventBus.publisher = this;
+  }
+
+  publish(event: IEvent, context?: unknown, asyncContext?: AsyncContext) {
+    return this.publishAll([event], context, asyncContext);
+  }
+
+  async publishAll(
+    events: IEvent[],
+    context?: unknown,
+    asyncContext?: AsyncContext,
+  ) {
+    await setImmediate();
+    const transaction = (context as { transaction?: Transaction } | undefined)
+      ?.transaction;
+    if (transaction?.fail) {
+      throw transaction.fail;
+    }
+    this.written.push({
+      orderIds: events.map((event) => (event as OrderPlacedEvent).orderId),
+      context,
+      asyncContext,
+    });
+    events.forEach((event) => this.inner.publish(event, context, asyncContext));
+    return `written in ${transaction?.id ?? 'no transaction'}`;
+  }
+}
+
+@CommandHandler(PlaceOrderCommand)
+class PlaceOrderHandler implements ICommandHandler<PlaceOrderCommand> {
+  constructor(private readonly publisher: EventPublisher) {}
+
+  async execute({ orderId, transaction, publishable }: PlaceOrderCommand) {
+    const order = publishable
+      ? new PublishableOrder(orderId)
+      : this.publisher.mergeObjectContext(new Order(orderId));
+    order.place();
+    return transaction ? order.commit({ transaction }) : order.commit();
+  }
+}
+
+@CommandHandler(ScopedPlaceOrderCommand, { scope: Scope.REQUEST })
+class ScopedPlaceOrderHandler implements ICommandHandler<ScopedPlaceOrderCommand> {
+  constructor(
+    private readonly publisher: EventPublisher,
+    @Inject(REQUEST) private readonly context: AsyncContext,
+  ) {}
+
+  async execute({ orderId, transaction }: ScopedPlaceOrderCommand) {
+    const MergedOrder = this.publisher.mergeClassContext(Order, this.context);
+    const order = new MergedOrder(orderId);
+    order.place();
+    return order.commit({ transaction });
+  }
+}
+
+@EventsHandler(OrderPlacedEvent)
+class OrderPlacedHandler implements IEventHandler<OrderPlacedEvent> {
+  static readonly handled: string[] = [];
+
+  handle(event: OrderPlacedEvent) {
+    OrderPlacedHandler.handled.push(event.orderId);
+  }
+}
+
+@Module({
+  imports: [CqrsModule.forRoot()],
+  providers: [
+    TransactionalEventPublisher,
+    PlaceOrderHandler,
+    ScopedPlaceOrderHandler,
+    OrderPlacedHandler,
+  ],
+})
+class OrdersModule {}
+
+describe('Aggregate commit with a dispatcher context', () => {
+  let moduleRef: TestingModule;
+  let commandBus: CommandBus;
+  let publisher: TransactionalEventPublisher;
+
+  beforeAll(async () => {
+    moduleRef = await Test.createTestingModule({
+      imports: [OrdersModule],
+    }).compile();
+    await moduleRef.init();
+
+    commandBus = moduleRef.get(CommandBus);
+    publisher = moduleRef.get(TransactionalEventPublisher);
+  });
+
+  beforeEach(() => {
+    publisher.written.length = 0;
+    OrderPlacedHandler.handled.length = 0;
+  });
+
+  afterAll(async () => {
+    await moduleRef.close();
+  });
+
+  it('awaits the publisher, which receives the transaction and the events', async () => {
+    const transaction = { id: 'tx-1' };
+
+    const result = await commandBus.execute(
+      new PlaceOrderCommand('order-1', transaction),
+    );
+
+    expect(result).toBe('written in tx-1');
+    expect(publisher.written).toEqual([
+      {
+        orderIds: ['order-1'],
+        context: { transaction },
+        asyncContext: undefined,
+      },
+    ]);
+    await waitImmediate();
+    expect(OrderPlacedHandler.handled).toEqual(['order-1']);
+  });
+
+  it("rejects with the publisher's error", async () => {
+    const fail = new Error('serialization failure');
+
+    await expect(
+      commandBus.execute(
+        new PlaceOrderCommand('order-2', { id: 'tx-2', fail }),
+      ),
+    ).rejects.toBe(fail);
+
+    await waitImmediate();
+    expect(publisher.written).toEqual([]);
+    expect(OrderPlacedHandler.handled).toEqual([]);
+  });
+
+  it('passes the transaction from a @Publishable() aggregate', async () => {
+    const transaction = { id: 'tx-3' };
+
+    await commandBus.execute(
+      new PlaceOrderCommand('order-3', transaction, true),
+    );
+
+    expect(publisher.written).toEqual([
+      {
+        orderIds: ['order-3'],
+        context: { transaction },
+        asyncContext: undefined,
+      },
+    ]);
+  });
+
+  it('keeps the async context of a request-scoped handler', async () => {
+    const asyncContext = new AsyncContext();
+    const transaction = { id: 'tx-4' };
+
+    await commandBus.execute(
+      new ScopedPlaceOrderCommand('order-4', transaction),
+      asyncContext,
+    );
+
+    expect(publisher.written).toEqual([
+      { orderIds: ['order-4'], context: { transaction }, asyncContext },
+    ]);
+  });
+
+  it('keeps passing the aggregate as the dispatcher context without one', async () => {
+    await commandBus.execute(new PlaceOrderCommand('order-5'));
+
+    expect(publisher.written).toHaveLength(1);
+    expect(publisher.written[0].context).toBeInstanceOf(Order);
+  });
+});

package/test/e2e/basic-flows.spec.ts

@@ -1,20 +1,24 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { setTimeout } from 'timers/promises';
-import { CommandBus, QueryBus } from '../../src';
-import { AppModule } from '../src/app.module';
-import { DropAncientItemHandler } from '../src/heroes/commands/handlers/drop-ancient-item.handler';
-import { KillDragonHandler } from '../src/heroes/commands/handlers/kill-dragon.handler';
-import { DropAncientItemCommand } from '../src/heroes/commands/impl/drop-ancient-item.command';
-import { KillDragonCommand } from '../src/heroes/commands/impl/kill-dragon.command';
-import { HeroFoundItemHandler } from '../src/heroes/events/handlers/hero-found-item.handler';
-import { HeroKilledDragonHandler } from '../src/heroes/events/handlers/hero-killed-dragon.handler';
-import { HeroFoundItemEvent } from '../src/heroes/events/impl/hero-found-item.event';
-import { HeroKilledDragonEvent } from '../src/heroes/events/impl/hero-killed-dragon.event';
-import { GetHeroesQuery } from '../src/heroes/queries/impl';
-import { HERO_ID } from '../src/heroes/repository/fixtures/user';
-import { ANCIENT_ITEM_ID } from '../src/heroes/sagas/heroes.sagas';
-import { NoopHandler } from '../src/noop/events/handlers/noop.handler';
-import { waitImmediate } from '../utils/wait-immediate';
+import type { MockInstance } from 'vitest';
+import { CommandBus, QueryBus } from '../../src/index.js';
+import { AppModule } from '../src/app.module.js';
+import { DropAncientItemHandler } from '../src/heroes/commands/handlers/drop-ancient-item.handler.js';
+import { KillDragonHandler } from '../src/heroes/commands/handlers/kill-dragon.handler.js';
+import { DropAncientItemCommand } from '../src/heroes/commands/impl/drop-ancient-item.command.js';
+import { KillDragonCommand } from '../src/heroes/commands/impl/kill-dragon.command.js';
+import { DragonDiedHandler } from '../src/heroes/events/handlers/dragon-died.handler.js';
+import { HeroFoundItemHandler } from '../src/heroes/events/handlers/hero-found-item.handler.js';
+import { HeroKilledDragonHandler } from '../src/heroes/events/handlers/hero-killed-dragon.handler.js';
+import { DragonDiedEvent } from '../src/heroes/events/impl/dragon-died.event.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';
+import { DRAGON_ID } from '../src/heroes/repository/fixtures/dragon.js';
+import { GetHeroesQuery, GetHeroQuery } from '../src/heroes/queries/impl/index.js';
+import { HERO_ID } from '../src/heroes/repository/fixtures/user.js';
+import { ANCIENT_ITEM_ID } from '../src/heroes/sagas/heroes.sagas.js';
+import { NoopHandler } from '../src/noop/events/handlers/noop.handler.js';
+import { waitImmediate } from '../utils/wait-immediate.js';
 
 describe('Basic flows', () => {
   let moduleRef: TestingModule;
@@ -28,23 +32,26 @@ describe('Basic flows', () => {
   });
 
   describe('when "KillDragonCommand" command is dispatched', () => {
-    let killDragonExecuteSpy: jest.SpyInstance;
-    let heroKilledDragonHandleSpy: jest.SpyInstance;
-    let noopEventHandleSpy: jest.SpyInstance;
+    let killDragonExecuteSpy: MockInstance;
+    let heroKilledDragonHandleSpy: MockInstance;
+    let dragonDiedHandleSpy: MockInstance;
+    let noopEventHandleSpy: MockInstance;
     let command: KillDragonCommand;
 
     beforeAll(async () => {
       const killDragonHandler = moduleRef.get(KillDragonHandler);
       const heroKilledDragonHandler = moduleRef.get(HeroKilledDragonHandler);
+      const dragonDiedHandler = moduleRef.get(DragonDiedHandler);
       const noopHandler = moduleRef.get(NoopHandler);
 
-      killDragonExecuteSpy = jest.spyOn(killDragonHandler, 'execute');
-      heroKilledDragonHandleSpy = jest.spyOn(heroKilledDragonHandler, 'handle');
-      noopEventHandleSpy = jest.spyOn(noopHandler, 'handle');
+      killDragonExecuteSpy = vi.spyOn(killDragonHandler, 'execute');
+      heroKilledDragonHandleSpy = vi.spyOn(heroKilledDragonHandler, 'handle');
+      dragonDiedHandleSpy = vi.spyOn(dragonDiedHandler, 'handle');
+      noopEventHandleSpy = vi.spyOn(noopHandler, 'handle');
 
       const commandBus = moduleRef.get(CommandBus);
       const heroId = HERO_ID;
-      const dragonId = 'dragonId';
+      const dragonId = DRAGON_ID;
 
       command = new KillDragonCommand(heroId, dragonId);
       await commandBus.execute(command);
@@ -60,19 +67,24 @@ describe('Basic flows', () => {
       expect(heroKilledDragonHandleSpy).toHaveBeenCalledWith(event);
     });
 
+    it('should handle "DragonDiedEvent" event from aggregate root', () => {
+      const event = new DragonDiedEvent(DRAGON_ID);
+      expect(dragonDiedHandleSpy).toHaveBeenCalledWith(event);
+    });
+
     it('should not trigger "NoopHandler" event', () => {
       expect(noopEventHandleSpy).not.toHaveBeenCalled();
     });
 
     describe('when saga triggered', () => {
-      let dropAncientExecuteSpy: jest.SpyInstance;
-      let heroFoundItemSpy: jest.SpyInstance;
+      let dropAncientExecuteSpy: MockInstance;
+      let heroFoundItemSpy: MockInstance;
 
       beforeAll(async () => {
         const dropAncientItemHandler = moduleRef.get(DropAncientItemHandler);
         const heroFoundItemHandler = moduleRef.get(HeroFoundItemHandler);
-        dropAncientExecuteSpy = jest.spyOn(dropAncientItemHandler, 'execute');
-        heroFoundItemSpy = jest.spyOn(heroFoundItemHandler, 'handle');
+        dropAncientExecuteSpy = vi.spyOn(dropAncientItemHandler, 'execute');
+        heroFoundItemSpy = vi.spyOn(heroFoundItemHandler, 'handle');
 
         // Wait 1 second for saga to be triggered
         await setTimeout(1000);
@@ -100,6 +112,14 @@ describe('Basic flows', () => {
     });
   });
 
+  describe('when "GetHeroQuery" query is executed', () => {
+    it('should return a single hero', async () => {
+      const queryBus = moduleRef.get(QueryBus);
+      const hero = await queryBus.execute(new GetHeroQuery(1234));
+      expect(hero).toEqual(expect.objectContaining({ id: HERO_ID }));
+    });
+  });
+
   afterAll(async () => {
     await moduleRef.close();
   });

package/test/e2e/generics.spec.ts

@@ -1,4 +1,4 @@
-import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper.js';
 import { Test, TestingModule } from '@nestjs/testing';
 import {
   Command,
@@ -6,8 +6,8 @@ import {
   ICommandHandler,
   Query,
   QueryBus,
-} from '../../src';
-import { AppModule } from '../src/app.module';
+} from '../../src/index.js';
+import { AppModule } from '../src/app.module.js';
 
 describe('Generics', () => {
   let moduleRef: TestingModule;

package/test/e2e/request-scope.spec.ts

@@ -1,19 +1,20 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { setTimeout } from 'timers/promises';
-import { AsyncContext, CommandBus, QueryBus } from '../../src';
-import { AppModule } from '../src/app.module';
-import { HERO_ID } from '../src/heroes/repository/fixtures/user';
-import { ANCIENT_ITEM_ID } from '../src/heroes/sagas/heroes.sagas';
-import { ScopedDropAncientItemHandler } from '../src/scoped/commands/handlers/scoped-drop-ancient-item.handler';
-import { ScopedKillDragonHandler } from '../src/scoped/commands/handlers/scoped-kill-dragon.handler';
-import { ScopedDropAncientItemCommand } from '../src/scoped/commands/impl/scoped-drop-ancient-item.command';
-import { ScopedKillDragonCommand } from '../src/scoped/commands/impl/scoped-kill-dragon.command';
-import { ScopedHeroFoundItemHandler } from '../src/scoped/events/handlers/scoped-hero-found-item.handler';
-import { ScopedHeroKilledDragonHandler } from '../src/scoped/events/handlers/scoped-hero-killed-dragon.handler';
-import { ScopedHeroFoundItemEvent } from '../src/scoped/events/impl/hero-found-item.event';
-import { ScopedHeroKilledDragonEvent } from '../src/scoped/events/impl/hero-killed-dragon.event';
-import { ScopedGetHeroesQuery } from '../src/scoped/queries/impl';
-import { waitImmediate } from '../utils/wait-immediate';
+import type { MockInstance } from 'vitest';
+import { AsyncContext, CommandBus, QueryBus } from '../../src/index.js';
+import { AppModule } from '../src/app.module.js';
+import { HERO_ID } from '../src/heroes/repository/fixtures/user.js';
+import { ANCIENT_ITEM_ID } from '../src/heroes/sagas/heroes.sagas.js';
+import { ScopedDropAncientItemHandler } from '../src/scoped/commands/handlers/scoped-drop-ancient-item.handler.js';
+import { ScopedKillDragonHandler } from '../src/scoped/commands/handlers/scoped-kill-dragon.handler.js';
+import { ScopedDropAncientItemCommand } from '../src/scoped/commands/impl/scoped-drop-ancient-item.command.js';
+import { ScopedKillDragonCommand } from '../src/scoped/commands/impl/scoped-kill-dragon.command.js';
+import { ScopedHeroFoundItemHandler } from '../src/scoped/events/handlers/scoped-hero-found-item.handler.js';
+import { ScopedHeroKilledDragonHandler } from '../src/scoped/events/handlers/scoped-hero-killed-dragon.handler.js';
+import { ScopedHeroFoundItemEvent } from '../src/scoped/events/impl/hero-found-item.event.js';
+import { ScopedHeroKilledDragonEvent } from '../src/scoped/events/impl/hero-killed-dragon.event.js';
+import { ScopedGetHeroesQuery } from '../src/scoped/queries/impl/index.js';
+import { waitImmediate } from '../utils/wait-immediate.js';
 
 describe('Request scope', () => {
   let moduleRef: TestingModule;
@@ -29,8 +30,8 @@ describe('Request scope', () => {
   describe('when "ScopedKillDragonCommand" command is dispatched', () => {
     const asyncContext = new AsyncContext();
 
-    let killDragonExecuteSpy: jest.SpyInstance;
-    let heroKilledDragonHandleSpy: jest.SpyInstance;
+    let killDragonExecuteSpy: MockInstance;
+    let heroKilledDragonHandleSpy: MockInstance;
     let command: ScopedKillDragonCommand;
 
     beforeAll(async () => {
@@ -45,8 +46,8 @@ describe('Request scope', () => {
         asyncContext.id,
       );
 
-      killDragonExecuteSpy = jest.spyOn(killDragonHandler, 'execute');
-      heroKilledDragonHandleSpy = jest.spyOn(heroKilledDragonHandler, 'handle');
+      killDragonExecuteSpy = vi.spyOn(killDragonHandler, 'execute');
+      heroKilledDragonHandleSpy = vi.spyOn(heroKilledDragonHandler, 'handle');
 
       const commandBus = moduleRef.get(CommandBus);
       const heroId = HERO_ID;
@@ -70,8 +71,8 @@ describe('Request scope', () => {
     });
 
     describe('when saga triggered', () => {
-      let dropAncientExecuteSpy: jest.SpyInstance;
-      let heroFoundItemSpy: jest.SpyInstance;
+      let dropAncientExecuteSpy: MockInstance;
+      let heroFoundItemSpy: MockInstance;
 
       beforeAll(async () => {
         const dropAncientItemHandler = await moduleRef.resolve(
@@ -82,8 +83,8 @@ describe('Request scope', () => {
           ScopedHeroFoundItemHandler,
           asyncContext.id,
         );
-        dropAncientExecuteSpy = jest.spyOn(dropAncientItemHandler, 'execute');
-        heroFoundItemSpy = jest.spyOn(heroFoundItemHandler, 'handle');
+        dropAncientExecuteSpy = vi.spyOn(dropAncientItemHandler, 'execute');
+        heroFoundItemSpy = vi.spyOn(heroFoundItemHandler, 'handle');
 
         // Wait 1 second for saga to be triggered
         await setTimeout(1000);