What is the correct way to work with transactions with NestJs and TypeORM?

When using the NestJs framework and TypeORM for database transaction handling, the proper approach is to leverage TypeORM's EntityManager or QueryRunner to manage transaction boundaries and ensure atomicity. Below, I will provide a detailed explanation of both methods with example code.

Using EntityManager to Control Transactions

The EntityManager provides a transaction method that accepts a callback function for executing all database operations. This callback function takes a new EntityManager instance (referred to as the transactional entity manager) that is tied to the current transaction context. All operations performed through this specific EntityManager will be executed within the same transaction.

Example Code:

typescript
import { Injectable } from '@nestjs/common';
import { InjectEntityManager } from '@nestjs/typeorm';
import { EntityManager } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectEntityManager()
    private entityManager: EntityManager,
  ) {}

  async createUserWithTransaction(userData: Partial<User>) {
    await this.entityManager.transaction(async transactionalEntityManager => {
      const newUser = transactionalEntityManager.create(User, userData);
      await transactionalEntityManager.save(User, newUser);
      
      // Additional database operations can be added here if needed, and they will all be committed within the same transaction.
    });
  }
}

Using QueryRunner to Control Transactions

The QueryRunner offers finer-grained control, including manual transaction initiation, termination, and rollback. This is particularly useful for scenarios requiring complex transaction management logic.

Example Code:

typescript
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository, Connection } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
    private connection: Connection,
  ) {}

  async createUserWithManualTransaction(userData: Partial<User>) {
    const queryRunner = this.connection.createQueryRunner();

    await queryRunner.connect();
    await queryRunner.startTransaction();
    try {
      const newUser = queryRunner.manager.create(User, userData);
      await queryRunner.manager.save(newUser);

      // Additional database operations can be performed here as long as they use `queryRunner.manager`.

      await queryRunner.commitTransaction();
    } catch (error) {
      // If an error occurs within the transaction, perform rollback
      await queryRunner.rollbackTransaction();
      throw error;
    } finally {
      // Release the query runner
      await queryRunner.release();
    }
  }
}

Summary

Both methods are effective for handling transactions with NestJs and TypeORM. The choice between them primarily depends on the specific application requirements. The EntityManager approach is suitable for most cases, especially when transaction logic is straightforward; whereas QueryRunner provides greater flexibility and control, making it ideal for complex transaction management.

During development, selecting the appropriate transaction management strategy ensures data consistency and integrity, avoiding potential data inconsistencies that may arise from concurrent operations.