refactor: abstracted UnitOfWork initiation

Author: Sairyss

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

@@ -7,10 +7,6 @@ import { WalletRepository } from '@modules/wallet/database/wallet.repository';
 export class UnitOfWork extends UnitOfWorkOrm {
   // Add new repositories below to use this generic UnitOfWork
 
-  init(): string {
-    return UnitOfWork.init();
-  }
-
   // Convert TypeOrm Repository to a Domain Repository
   getUserRepository(correlationId: string): UserRepository {
     return new UserRepository(

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

@@ -0,0 +1,16 @@
+import { UnitOfWorkOrm } from '../../infrastructure/database/base-classes/unit-of-work-orm';
+import { ID } from '../value-objects/id.value-object';
+import { Command } from './command.base';
+
+export abstract class CommandHandler<UnitOfWork extends UnitOfWorkOrm> {
+  constructor(protected readonly unitOfWork: UnitOfWork) {}
+
+  protected abstract execute(command: Command): Promise<ID>;
+
+  async executeUnitOfWork(command: Command): Promise<ID> {
+    UnitOfWorkOrm.init(command.correlationId);
+    return UnitOfWorkOrm.execute(command.correlationId, async () =>
+      this.execute(command),
+    );
+  }
+}

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

@@ -0,0 +1,18 @@
+import { nanoid } from 'nanoid';
+import { ArgumentNotProvidedException } from '../../../exceptions';
+import { Guard } from '../guard';
+
+export type CommandProps<T> = Omit<T, 'correlationId'> & Partial<Command>;
+
+export class Command {
+  public readonly correlationId: string;
+
+  constructor(props: CommandProps<unknown>) {
+    if (Guard.isEmpty(props)) {
+      throw new ArgumentNotProvidedException(
+        'Command props should not be empty',
+      );
+    }
+    this.correlationId = props.correlationId || nanoid(8);
+  }
+}

src/libs/ddd/domain/domain-events/domain-event.base.ts

@@ -1,7 +1,32 @@
+import { ArgumentNotProvidedException } from '../../../exceptions';
+import { Guard } from '../guard';
+
+export type DomainEventProps<T> = Omit<T, 'correlationId' | 'dateOccurred'> &
+  Omit<DomainEvent, 'correlationId' | 'dateOccurred'> & {
+    correlationId?: string;
+    dateOccurred?: number;
+  };
+
 export abstract class DomainEvent {
-  constructor(
-    public readonly aggregateId: string,
-    public readonly dateOccurred: number,
-    public correlationId?: string,
-  ) {}
+  /** Aggregate ID where domain event occurred */
+  public readonly aggregateId: string;
+
+  /** Date when this domain event occurred */
+  public readonly dateOccurred: number;
+
+  /** ID for correlation purposes (for UnitOfWork, Integration Events,logs correlation etc).
+   * This ID is set automatically in a publisher.
+   */
+  public correlationId: string;
+
+  constructor(props: DomainEventProps<unknown>) {
+    if (Guard.isEmpty(props)) {
+      throw new ArgumentNotProvidedException(
+        'DomainEvent props should not be empty',
+      );
+    }
+    this.aggregateId = props.aggregateId;
+    this.dateOccurred = props.dateOccurred || Date.now();
+    if (props.correlationId) this.correlationId = props.correlationId;
+  }
 }

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

@@ -1,19 +1,18 @@
 import { Logger } from '@nestjs/common';
 import { EntityTarget, getConnection, QueryRunner, Repository } from 'typeorm';
-import { nanoid } from 'nanoid';
 
 export class UnitOfWorkOrm {
   private static queryRunners: Map<string, QueryRunner> = new Map();
 
   /**
-   * Create a connection pool and get its ID.
-   * ID is used for correlation purposes (to use a correct query runner, correlate logs etc)
+   * Creates a connection pool with a specified ID.
    */
-  static init(): string {
+  static init(correlationId: string): void {
+    if (!correlationId) {
+      throw new Error('Correlation ID must be provided');
+    }
     const queryRunner = getConnection().createQueryRunner();
-    const correlationId = nanoid(8);
     this.queryRunners.set(correlationId, queryRunner);
-    return correlationId;
   }
 
   static getQueryRunner(correlationId: string): QueryRunner {
@@ -47,7 +46,7 @@ export class UnitOfWorkOrm {
     const logger = new Logger(`${this.name}:${correlationId}`);
     logger.debug(`[Starting transaction]`);
     const queryRunner = this.getQueryRunner(correlationId);
-    await queryRunner.startTransaction();
+    await queryRunner.startTransaction('SERIALIZABLE');
     let result: T;
     try {
       result = await callback();

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

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

src/modules/user/commands/create-user/create-user.command.ts

@@ -1,6 +1,12 @@
+import {
+  Command,
+  CommandProps,
+} from '@src/libs/ddd/domain/base-classes/command.base';
+
 // Command is a plain object with properties
-export class CreateUserCommand {
-  constructor(props: CreateUserCommand) {
+export class CreateUserCommand extends Command {
+  constructor(props: CommandProps<CreateUserCommand>) {
+    super(props);
     this.email = props.email;
     this.country = props.country;
     this.postalCode = props.postalCode;

src/modules/user/commands/create-user/create-user.http.controller.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.execute(command);
+    const id = await this.service.executeUnitOfWork(command);
 
     return new IdResponse(id.value);
   }

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

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

src/modules/user/commands/create-user/create-user.service.ts

@@ -4,16 +4,15 @@ 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';
+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 {
-  constructor(private readonly unitOfWork: UnitOfWork) {}
-
-  async create(
-    command: CreateUserCommand,
-    userRepo: UserRepositoryPort,
-  ): Promise<ID> {
+export class CreateUserService extends CommandHandler<UnitOfWork> {
+  protected async execute(command: CreateUserCommand): Promise<ID> {
+    const userRepo: UserRepositoryPort = this.unitOfWork.getUserRepository(
+      command.correlationId,
+    );
     // user uniqueness guard
     if (await userRepo.exists(command.email)) {
       throw new ConflictException('User already exists');
@@ -34,15 +33,4 @@ export class CreateUserService {
 
     return created.id;
   }
-
-  async execute(command: CreateUserCommand): Promise<ID> {
-    const correlationId = this.unitOfWork.init();
-    const userRepo: UserRepositoryPort = this.unitOfWork.getUserRepository(
-      correlationId,
-    );
-    // Wrapping user creation in a UnitOfWork so events get included in a transaction
-    return UnitOfWork.execute(correlationId, async () =>
-      this.create(command, userRepo),
-    );
-  }
 }

src/modules/user/domain/entities/user.entity.ts

@@ -19,10 +19,10 @@ export interface UserProps extends CreateUserProps {
 export class UserEntity extends AggregateRoot<UserProps> {
   protected readonly _id: UUID;
 
-  static create(createUser: CreateUserProps): UserEntity {
+  static create(create: CreateUserProps): UserEntity {
     const id = UUID.generate();
-    // Setting a default role since it is not accepted during creation
-    const props: UserProps = { ...createUser, role: UserRoles.guest };
+    /* Setting a default role since we are not accepting it during creation. */
+    const props: UserProps = { ...create, role: UserRoles.guest };
     const user = new UserEntity({ id, props });
     /* adding "UserCreated" Domain Event that will be published
     eventually so an event handler somewhere may receive it and do an
@@ -32,7 +32,6 @@ export class UserEntity extends AggregateRoot<UserProps> {
         aggregateId: id.value,
         email: props.email.getRawProps(),
         ...props.address.getRawProps(),
-        dateOccurred: Date.now(),
       }),
     );
     return user;
@@ -63,6 +62,8 @@ export class UserEntity extends AggregateRoot<UserProps> {
       ...this.props.address,
       ...props,
     } as AddressProps);
+
+    // Note: AddressUpdatedDomainEvent can be emitted here if needed.
   }
 
   someBusinessLogic(): void {

src/modules/user/domain/events/user-created.domain-event.ts

@@ -1,9 +1,9 @@
-import { DomainEvent } from '@libs/ddd/domain/domain-events';
+import { DomainEvent, DomainEventProps } from '@libs/ddd/domain/domain-events';
 
 // DomainEvent is a plain object with properties
 export class UserCreatedDomainEvent extends DomainEvent {
-  constructor(props: UserCreatedDomainEvent) {
-    super(props.aggregateId, props.dateOccurred);
+  constructor(props: DomainEventProps<UserCreatedDomainEvent>) {
+    super(props);
     this.email = props.email;
     this.country = props.country;
     this.postalCode = props.postalCode;