小编mom*_*omo的帖子

目前，三个不同的存储库需要将某些内容作为单个事务进行处理。

我的服务代码写如下。但与我想象的不同，每个存储库都生成自己的事务。我怎么解决这个问题？

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

Typeorm的官方文档规定，如果使用Lazy，则必须使用promise。如果不承诺，默认的获取类型会是急切加载吗？但是，我检查了一下，它似乎正在加载 Lazy，而不是 Eager。JPA默认的音高类型如下：

OneToMany: LAZY
ManyToOne: EAGER
ManyToMany: LAZY
OneToOne: EAGER

TypeOrm 的默认获取类型是否相同？