TypeORM 是否为不同的存储库提供事务？答案

【问题标题】：Does TypeORM provide transactions for different repositories?TypeORM 是否为不同的存储库提供事务？
【发布时间】：2022-01-05 06:59:14
【问题描述】：

目前，三个不同的存储库需要作为一个事务处理。

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

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

【问题讨论】：

标签： nestjs typeorm

【解决方案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);
    }
}

【讨论】：