nestjs / TypeOrm database transaction

Many solutions are available, they should all be based on SQL transaction management.

Personally I feel that the simplest way to achieve that is to use the same EntityManager instance when you execute code on your database. Then you can use something like:

getConnection().transaction(entityManager -> {

You can spawn a QueryRunner from an EntityManager instance that will be wrapped in the same transaction in case you execute raw SQL outside ORM operations. You need also to spawn Repository instances from EntityManager as well or they will execute code outside the main transaction.

Here is how I solved it since I needed to use a pessimistic lock.

I feel it is the "Nest" way of doing things as you can simply ask NestJS to inject an instance of a Typeorm Connection and you're good to go.

class MyService {
  // 1. Inject the Typeorm Connection
  constructor(@InjectConnection() private connection: Connection) { }

  async findById(id: number): Promise<Thing> {
    return new Promise(resolve => {
      // 2. Do your business logic
      this.connection.transaction(async entityManager => {
          await entityManager.findOne(Thing, id, {
            lock: { mode: 'pessimistic_write' },

Simply place whatever other logic you need inside the .transaction block and you're good to go.

NOTE: You MUST use the entityManager provided by the .transaction method or else it will not work.

typeorm-transactional-cls-hooked uses CLS (Continuation Local Storage) to handle and propagate transactions between different repositories and service methods.

export class PostService {
    private readonly authorRepository: AuthorRepository,
    private readonly postRepository: PostRepository,
  ) {}

  @Transactional() // will open a transaction if one doesn't already exist
  async createPost(authorUsername: string, message: string): Promise<Post> {
    const author = await this.authorRepository.create({ username: authorUsername });
    return{ message, author_id: });