Does TypeORM provide transactions for different repositories?

Question

Currently, three different repositories have something to deal with as a single transaction.

My service code is written as follows. But unlike what I thought, each repository is generating its own transaction. How can I solve this problem?

// TrimService

@Injectable()
export class TrimService {
    constructor(
        private readonly trimRepository: TrimRepository,
        private readonly tireRepository: TireRepository,
        private readonly userRepository: UserRepository
    ) {}

    async saveUserTrim(saveUserTrimDto: SaveUserTrimDto, res) {
        const queryRunner = await getConnection().createQueryRunner();
        await queryRunner.startTransaction();

        try {
            const findUser: User = await this.userRepository.findUser(
                saveUserTrimDto.id,
                queryRunner.manager
            );

            const createTrim: Trim = await this.trimRepository.saveUserTrim(
                findUser,
                saveUserTrimDto.trimId,
                queryRunner.manager
            );

            await this.tireRepository.saveTrimTire(
                createTrim,
                res,
                queryRunner.manager
            );

            await queryRunner.commitTransaction();
            return createTrim;
        } catch (err) {
            console.log(err);
            await queryRunner.rollbackTransaction();
        } finally {
            await queryRunner.release();
        }
    }
}

// userRepository

@EntityRepository(User)
export class UserRepository extends Repository<User> {
    async findUser(
        id: string,
        @TransactionManager() transactionManager?: EntityManager
    ) {
        const findUser = await this.findOne({ id: id });

        if (!findUser) {
            throw new NotFoundUserException();
        }

        return findUser;
    }
}

Answer 1

I solved this problem. Transaction Manager was received from each query and the method had to be used. Since userRepository is findOne, transaction processing has not been performed.

// TrimService

@Injectable()
export class TrimService {
    constructor(
        private readonly trimRepository: TrimRepository,
        private readonly tireRepository: TireRepository,
        private readonly userRepository: UserRepository
    ) {}

    async saveUserTrim(saveUserTrimDto: SaveUserTrimDto, res) {
        const queryRunner = await getConnection().createQueryRunner();
        await queryRunner.startTransaction();

        const findUser: User = await this.userRepository.findUser(
            saveUserTrimDto.id
        );

        try {
            const createTrim: Trim = await this.trimRepository.saveUserTrim(
                queryRunner.manager,
                findUser,
                saveUserTrimDto.trimId
            );

            await this.tireRepository.saveTrimTire(
                queryRunner.manager,
                createTrim,
                res
            );

            await queryRunner.commitTransaction();
            return createTrim;
        } catch (err) {
            console.log(err);
            await queryRunner.rollbackTransaction();
        } finally {
            await queryRunner.release();
        }
    }
}

// TrimRepository

@EntityRepository(Trim)
export class TrimRepository extends Repository<Trim> {
    async saveUserTrim(
        @TransactionManager() transactionManager: EntityManager,
        findUser: User,
        trimId: number
    ) {
        const findTrim = await transactionManager.findOne(Trim, {
            trimId: trimId,
            user: findUser
        });

        if (findTrim) {
            throw new TrimOverlapException();
        }

        const createTrim: Trim = await transactionManager.create(Trim, {
            trimId: trimId,
            user: findUser
        });

        return await transactionManager.save(Trim, createTrim);
    }
}