refactor: removed CommandHandlerBase and simplified UnitOfWork

Author: Sairyss

README.md

@@ -261,7 +261,7 @@ Some CQS purists may say that a `Command` shouldn't return anything at all. But
 
 Though, violating this rule and returning some metadata, like `ID` of a created item, redirect link, confirmation message, status, or other metadata is a more practical approach than following dogmas.
 
-All changes done by `Commands` (or by events or anything else) across multiple aggregates should be saved in a single database transaction (if you are using a single database). This means that inside a single process, one command/request to your application usually should execute **only one** [transactional operation](https://en.wikipedia.org/wiki/Database_transaction) to save **all** changes (or cancel **all** changes of that command/request in case if something fails). This should be done to maintain consistency. To do that something like [Unit of Work](https://www.c-sharpcorner.com/UploadFile/b1df45/unit-of-work-in-repository-pattern/) or similar patterns can be used. Example: [create-user.service.ts](src/modules/user/commands/create-user/create-user.service.ts) - notice how it extends a `CommandHandler<UnitOfWork>` and gets a transactional repository from `this.unitOfWork`.
+All changes done by `Commands` (or by events or anything else) across multiple aggregates should be saved in a single database transaction (if you are using a single database). This means that inside a single process, one command/request to your application usually should execute **only one** [transactional operation](https://en.wikipedia.org/wiki/Database_transaction) to save **all** changes (or cancel **all** changes of that command/request in case if something fails). This should be done to maintain consistency. To do that something like [Unit of Work](https://www.c-sharpcorner.com/UploadFile/b1df45/unit-of-work-in-repository-pattern/) or similar patterns can be used. Example: [create-user.service.ts](src/modules/user/commands/create-user/create-user.service.ts) - notice how it gets a transactional repository from `this.unitOfWork`.
 
 **Note**: `Command` is not the same as [Command Pattern](https://refactoring.guru/design-patterns/command), it is just a convenient name to represent that this object executes some state-changing action. Both `Commands` and `Queries` in this example are just simple objects that carry data between layers.
 
@@ -414,7 +414,7 @@ An alternative approach would be publishing a `Domain Event`. If executing a com
 
 Domain Events may be useful for creating an [audit log](https://en.wikipedia.org/wiki/Audit_trail) to track all changes to important entities by saving each event to the database. Read more on why audit logs may be useful: [Why soft deletes are evil and what to do instead](https://jameshalsall.co.uk/posts/why-soft-deletes-are-evil-and-what-to-do-instead).
 
-All changes done by Domain Events (or by anything else) across multiple aggregates in a single process should be saved in a single database transaction to maintain consistency. Patterns like [Unit of Work](https://www.c-sharpcorner.com/UploadFile/b1df45/unit-of-work-in-repository-pattern/) or similar can help with that. Example: [src/modules/wallet/wallet.providers.ts](src/modules/wallet/wallet.providers.ts) - notice how `OnUserCreatedDomainEventHandler` has a factory for creating an instance of this class with included transactional repository.
+All changes done by Domain Events (or by anything else) across multiple aggregates in a single process should be saved in a single database transaction to maintain consistency. Patterns like [Unit of Work](https://www.c-sharpcorner.com/UploadFile/b1df45/unit-of-work-in-repository-pattern/) or similar can help with that.
 
 **Note**: this project uses custom implementation for publishing Domain Events. Reason for not using [Node Event Emitter](https://nodejs.org/api/events.html) or packages that offer an event bus (like [NestJS CQRS](https://docs.nestjs.com/recipes/cqrs)) is that they don't offer an option to `await` for all events to finish, which is useful when making all events a part of a transaction. Inside a single process either all changes done by events should be saved, or none of them in case if one of the events fails.
 
@@ -426,6 +426,11 @@ Examples:
 - [user-created.domain-event.ts](src/modules/user/domain/events/user-created.domain-event.ts) - simple object that holds data related to published event.
 - [create-wallet-when-user-is-created.domain-event-handler.ts](src/modules/wallet/application/event-handlers/create-wallet-when-user-is-created.domain-event-handler.ts) - this is an example of Domain Event Handler that executes some actions when a domain event is raised (in this case, when user is created it also creates a wallet for that user).
 - [typeorm.repository.base.ts](src/libs/ddd/infrastructure/database/base-classes/typeorm.repository.base.ts) - repository publishes all domain events for execution when it persists changes to an aggregate.
+- [typeorm-unit-of-work.ts](src/libs/ddd/infrastructure/database/base-classes/typeorm-unit-of-work.ts) - this ensures that everything is saved in a single transaction.
+- [unit-of-work.ts](src/infrastructure/database/unit-of-work/unit-of-work.ts) - here you create factories for specific Domain Repositories that are used in a transaction.
+- [create-user.service.ts](src/modules/user/commands/create-user/create-user.service.ts) - here we get a user repository from a `UnitOfWork` and execute a transaction.
+
+**Note**: Unit of work is not required for some operations (for example queries or operations that don't cause any side-effects in other aggregates) so you may skip using a unit of work in this cases and just use a regular repository injected through a constructor instead of a repository from a unit of work.
 
 To have a better understanding on domain events and implementation read this:
 

src/infrastructure/database/unit-of-work/unit-of-work.module.ts

@@ -1,7 +1,7 @@
-import { Global, Module } from '@nestjs/common';
+import { Global, Logger, Module } from '@nestjs/common';
 import { UnitOfWork } from './unit-of-work';
 
-const unitOfWorkSingleton = new UnitOfWork();
+const unitOfWorkSingleton = new UnitOfWork(new Logger());
 
 const unitOfWorkSingletonProvider = {
   provide: UnitOfWork,

src/libs/ddd/domain/base-classes/command-handler.base.ts

@@ -1,5 +1,4 @@
 export interface UnitOfWorkPort {
-  init(correlationId: string): void;
   execute<T>(
     correlationId: string,
     callback: () => Promise<T>,

src/libs/ddd/domain/ports/unit-of-work.port.ts

@@ -1,27 +1,18 @@
-import { Logger } from '@nestjs/common';
 import { UnitOfWorkPort } from '@src/libs/ddd/domain/ports/unit-of-work.port';
 import { EntityTarget, getConnection, QueryRunner, Repository } from 'typeorm';
 import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel';
+import { Logger } from 'src/libs/ddd/domain/ports/logger.port';
 
 export class TypeormUnitOfWork implements UnitOfWorkPort {
-  private queryRunners: Map<string, QueryRunner> = new Map();
+  constructor(private readonly logger: Logger) {}
 
-  /**
-   * Creates a connection pool with a specified ID.
-   */
-  init(correlationId: string): void {
-    if (!correlationId) {
-      throw new Error('Correlation ID must be provided');
-    }
-    const queryRunner = getConnection().createQueryRunner();
-    this.queryRunners.set(correlationId, queryRunner);
-  }
+  private queryRunners: Map<string, QueryRunner> = new Map();
 
   getQueryRunner(correlationId: string): QueryRunner {
     const queryRunner = this.queryRunners.get(correlationId);
     if (!queryRunner) {
       throw new Error(
-        'Query runner not found. UnitOfWork must be initiated first. Use "UnitOfWork.init()" method.',
+        'Query runner not found. Incorrect correlationId or transaction is not started. To start a transaction wrap operations in a `execute` method.',
       );
     }
     return queryRunner;
@@ -37,28 +28,36 @@ export class TypeormUnitOfWork implements UnitOfWorkPort {
 
   /**
    * Execute a UnitOfWork.
-   * Database operations wrapped in a UnitOfWork will execute in a single
-   * transactional operation, so everything gets saved or nothing.
+   * Database operations wrapped in a `execute` method will run
+   * in a single transactional operation, so everything gets
+   * saved (including changes done by Domain Events) or nothing at all.
    */
   async execute<T>(
     correlationId: string,
     callback: () => Promise<T>,
     options?: { isolationLevel: IsolationLevel },
   ): Promise<T> {
-    const logger = new Logger(`${this.constructor.name}:${correlationId}`);
-    logger.debug(`[Starting transaction]`);
-    const queryRunner = this.getQueryRunner(correlationId);
+    if (!correlationId) {
+      throw new Error('Correlation ID must be provided');
+    }
+    this.logger.setContext(`${this.constructor.name}:${correlationId}`);
+    const queryRunner = getConnection().createQueryRunner();
+    this.queryRunners.set(correlationId, queryRunner);
+    this.logger.debug(`[Starting transaction]`);
     await queryRunner.startTransaction(options?.isolationLevel);
+    // const queryRunner = this.getQueryRunner(correlationId);
     let result: T;
     try {
       result = await callback();
     } catch (error) {
       try {
         await queryRunner.rollbackTransaction();
+        this.logger.debug(
+          `[Transaction rolled back] ${(error as Error).message}`,
+        );
       } finally {
         await this.finish(correlationId);
       }
-      logger.debug(`[Transaction rolled back] ${(error as Error).message}`);
       throw error;
     }
     try {
@@ -67,7 +66,7 @@ export class TypeormUnitOfWork implements UnitOfWorkPort {
       await this.finish(correlationId);
     }
 
-    logger.debug(`[Transaction committed]`);
+    this.logger.debug(`[Transaction committed]`);
 
     return result;
   }

src/libs/ddd/infrastructure/database/base-classes/typeorm-unit-of-work.ts

@@ -38,7 +38,7 @@ export class CreateUserCliController {
       street,
     });
 
-    const id = await this.service.executeUnitOfWork(command);
+    const id = await this.service.execute(command);
 
     this.logger.log('User created:', id.value);
   }

src/modules/user/commands/create-user/create-user.cli.controller.ts

@@ -19,7 +19,7 @@ export class CreateUserGraphqlResolver {
   async create(@Args('input') input: CreateUserRequest): Promise<IdResponse> {
     const command = new CreateUserCommand(input);
 
-    const id = await this.service.executeUnitOfWork(command);
+    const id = await this.service.execute(command);
 
     return new IdResponse(id.value);
   }

src/modules/user/commands/create-user/create-user.graphql-resolver.ts

@@ -30,7 +30,7 @@ export class CreateUserHttpController {
   async create(@Body() body: CreateUserHttpRequest): Promise<IdResponse> {
     const command = new CreateUserCommand(body);
 
-    const id = await this.service.executeUnitOfWork(command);
+    const id = await this.service.execute(command);
 
     return new IdResponse(id.value);
   }

src/modules/user/commands/create-user/create-user.http.controller.ts

@@ -17,7 +17,7 @@ export class CreateUserMessageController {
   async create(message: CreateUserMessageRequest): Promise<IdResponse> {
     const command = new CreateUserCommand(message);
 
-    const id = await this.service.executeUnitOfWork(command);
+    const id = await this.service.execute(command);
 
     return new IdResponse(id.value);
   }

src/modules/user/commands/create-user/create-user.message.controller.ts

@@ -4,36 +4,38 @@ import { ConflictException } from '@libs/exceptions';
 import { Address } from '@modules/user/domain/value-objects/address.value-object';
 import { Email } from '@modules/user/domain/value-objects/email.value-object';
 import { UnitOfWork } from '@src/infrastructure/database/unit-of-work/unit-of-work';
-import { CommandHandler } from '@src/libs/ddd/domain/base-classes/command-handler.base';
 import { CreateUserCommand } from './create-user.command';
 import { UserEntity } from '../../domain/entities/user.entity';
 
-export class CreateUserService extends CommandHandler<UnitOfWork> {
-  protected async execute(command: CreateUserCommand): Promise<ID> {
+export class CreateUserService {
+  constructor(protected readonly unitOfWork: UnitOfWork) {}
+
+  async execute(command: CreateUserCommand): Promise<ID> {
     /* Use a repository provided by UnitOfWork to include everything 
        (including changes caused by Domain Events) into one 
        atomic database transaction */
-    const userRepo: UserRepositoryPort = this.unitOfWork.getUserRepository(
-      command.correlationId,
-    );
-    // user uniqueness guard
-    if (await userRepo.exists(command.email)) {
-      throw new ConflictException('User already exists');
-    }
-
-    const user = UserEntity.create({
-      email: new Email(command.email),
-      address: new Address({
-        country: command.country,
-        postalCode: command.postalCode,
-        street: command.street,
-      }),
-    });
+    return this.unitOfWork.execute(command.correlationId, async () => {
+      const userRepo: UserRepositoryPort = this.unitOfWork.getUserRepository(
+        command.correlationId,
+      );
+      // user uniqueness guard
+      if (await userRepo.exists(command.email)) {
+        throw new ConflictException('User already exists');
+      }
 
-    user.someBusinessLogic();
+      const user = UserEntity.create({
+        email: new Email(command.email),
+        address: new Address({
+          country: command.country,
+          postalCode: command.postalCode,
+          street: command.street,
+        }),
+      });
 
-    const created = await userRepo.save(user);
+      user.someBusinessLogic();
 
-    return created.id;
+      const created = await userRepo.save(user);
+      return created.id;
+    });
   }
 }