TypeORM 是否为不同的存储库提供交易？

Question

目前，三个不同的存储库有一些东西要作为一个事务来处理。

我的服务代码是这样写的。但与我的想法不同，每个存储库都在生成自己的事务。我该如何解决这个问题？

// 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

我解决了这个问题。从每个查询中收到事务管理器，必须使用该方法。由于userRepository是findOne，还没有进行事务处理

// 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);
    }
}

TypeORM 是否为不同的存储库提供交易？

Does TypeORM provide transactions for different repositories?

typeorm

nestjs