Transactions

WARNING

You need to use @wisemen/nestjs-typeorm instead of @nest/typeorm.

Default repositories must be injected with InjectRepository.

Custom repositories must extend from TypeOrmRepository.

To ensure data integrity, it is sometimes necessary to group multiple database operations into a single transaction. When one of the operations fails, the entire transaction will be rolled back. This prevents partial updates and maintains data integrity.

Why Transactions?

If your logic updates multiple entities, a transaction ensures consistency. Without it, a failure mid-operation might leave the database in an inconsistent state.

Key Points:

1. Avoid keeping transactions open longer than necessary.
2. Avoid other asynchronous operations within the transaction callback. (e.g., API calls, file operations, ...)
3. Only include logic within the transaction that absolutely requires rollback support.

When to Avoid Transactions:

• For simple fetch or insert operations.
• When rollback is not a concern.

Using Transactions

To group multiple operations into a single transaction you can use the transaction() helper function. This will use the AsyncLocalStorage functionality to make sure every query run in this scope will uses the transaction.

import { InjectRepository, transaction } from '@wisemen/nestjs-typeorm'

export class ActivateUserUseCase {
  constructor(
    private readonly dataSource: DataSource,
    @InjectRepository(User)
    private userRepository: Repository<User>,
    @InjectRepository(AnotherEntity)
    private anotherEntityRepository: Repository<AnotherEntity>
  ) {}

  async execute(input: string): Promise<void> {
     await transaction(this.datasource, async () => {
      await this.userRepository.update({
        email: input
      }, {
        isActive: true
      })

      await this.anotherEntityRepository.update({
        email: input
      }, {
        isActive: true
      })
    })
  }
}

This transaction function executes the given callback within a transaction. When the given callback function completes successfully, the transaction is committed. If an error occurs within the callback, the transaction is rolled back.

If for some reason, you need to use the entity manager which holds the transaction, you can access it as the first argument of the callback function.

Checkpoints

Executing multiple nested transactions makes a checkpoint for each call within the first transaction.