Mikro-ORM中显式事务的afterTransactionCommit能否追踪工作单元变更？

在afterFlush事件中，我们能通过args.uow.getChangeSets()获取实体变更，但在使用transactional()方法的显式事务里，afterTransactionCommit钩子中的uow为未定义状态。以下是几种实现类似afterFlush获取变更效果的方案：

方案1：手动跟踪事务内的实体变更 #

在显式事务的执行逻辑中，直接从EntityManager的内部UnitOfWork获取变更集，再存储到可在钩子中访问的位置：

import { EntityManager } from "typeorm";

async function updateUserTransactional() {
  await this.entityManager.transactional(async (manager: EntityManager) => {
    // 执行实体操作
    const user = await manager.findOneBy(User, { id: 1 });
    user.name = "New Name";
    await manager.save(user);

    // 从EntityManager的内部UnitOfWork获取变更集
    const uow = (manager as any).unitOfWork;
    const changeSets = uow.getChangeSets();

    // 存储变更集，比如用类属性暂存
    this.pendingChangeSets = changeSets;
  });
}

// 在afterTransactionCommit钩子中使用暂存的变更集
async afterTransactionCommit(): Promise<void> {
  if (this.pendingChangeSets) {
    // 执行和afterFlush一致的处理逻辑
    this.handleChangeSets(this.pendingChangeSets);
    // 清理暂存数据，避免内存泄漏
    this.pendingChangeSets = null;
  }
}

注意：直接访问unitOfWork属于依赖TypeORM内部实现，版本升级时需要验证兼容性。

方案2：通过事件订阅关联事务与变更集 #

创建自定义事件订阅，利用事务生命周期事件和afterFlush联动，按事务ID存储变更集，在事务提交时取出：

import { EventSubscriber, TransactionStartEventArgs, FlushEventArgs, TransactionCommitEventArgs, TransactionRollbackEventArgs } from "typeorm";

@EventSubscriber()
export class TransactionChangeSubscriber {
  private transactionChangeMap = new Map<string, any[]>();

  async beforeTransactionStart(args: TransactionStartEventArgs): Promise<void> {
    // 为新事务初始化变更存储
    this.transactionChangeMap.set(args.transactionId, []);
  }

  async afterFlush(args: FlushEventArgs): Promise<void> {
    // 仅在事务内的flush时存储变更集
    if (args.uow?.isTransactionActive) {
      const changeSets = args.uow.getChangeSets();
      this.transactionChangeMap.set(args.uow.transactionId, changeSets);
    }
  }

  async afterTransactionCommit(args: TransactionCommitEventArgs): Promise<void> {
    // 根据事务ID获取对应变更集
    const changeSets = this.transactionChangeMap.get(args.transactionId);
    if (changeSets) {
      // 执行变更处理逻辑
      this.processChangeSets(changeSets);
      // 清理存储，释放内存
      this.transactionChangeMap.delete(args.transactionId);
    }
  }

  async afterTransactionRollback(args: TransactionRollbackEventArgs): Promise<void> {
    // 事务回滚时清理无效的变更存储
    this.transactionChangeMap.delete(args.transactionId);
  }

  private processChangeSets(changeSets: any[]) {
    // 这里实现和afterFlush一致的处理逻辑
  }
}

这种方式不依赖内部API，通过TypeORM官方事件机制实现，兼容性和稳定性更好。

方案3：利用QueryRunner访问变更集 #

在显式事务中，通过EntityManager的queryRunner获取关联的UnitOfWork：

await this.entityManager.transactional(async (manager: EntityManager) => {
  // 执行实体操作
  const post = await manager.findOneBy(Post, { id: 5 });
  post.content = "Updated Content";
  await manager.save(post);

  // 通过queryRunner获取UnitOfWork
  const queryRunner = manager.queryRunner;
  if (queryRunner?.isTransactionActive) {
    const uow = queryRunner.manager.unitOfWork;
    const changeSets = uow.getChangeSets();
    // 可直接处理变更集，或存储后在钩子中使用
    this.tempChangeSets = changeSets;
  }
});

queryRunner是TypeORM公开API的一部分，相比直接访问内部属性更可靠。

内容的提问来源于stack exchange，提问作者Miguel Garcia