MikroORM 트랜잭션

const user = new User('George');
const profile = new Profile(user);

em.persist(user);
em.persist(profile);

await em.flush();
// 내부적으로: BEGIN → INSERT user → INSERT profile → COMMIT

await em.transactional(async (em) => {
  const order = new Order(customer);
  em.persist(order);

  const product = await em.findOneOrFail(Product, productId);
  product.stock -= quantity;

  const payment = new Payment(order, amount);
  em.persist(payment);
});
// 콜백이 정상 완료되면 → 자동 flush + commit
// 콜백에서 에러가 throw되면 → 자동 rollback

const em = orm.em.fork();
await em.begin();

try {
  const user = new User('George');
  em.persist(user);

  // raw 쿼리도 같은 트랜잭션에 포함
  await em.execute('UPDATE counters SET value = value + 1 WHERE name = ?', ['users']);

  await em.commit(); // flush 후 commit
} catch (e) {
  await em.rollback();
  throw e;
}

import { Transactional } from '@mikro-orm/core';

export class OrderService {
  constructor(private readonly em: EntityManager) {}

  @Transactional()
  async createOrder(customerId: number, items: OrderItem[]) {
    const customer = await this.em.findOneOrFail(Customer, customerId);
    const order = new Order(customer);

    for (const item of items) {
      const product = await this.em.findOneOrFail(Product, item.productId);
      product.stock -= item.quantity;
      order.items.add(new OrderLine(product, item.quantity));
    }

    this.em.persist(order);
    // 메서드 종료 시 자동 flush + commit
  }
}

// ❌ 위험: 글로벌 em을 직접 사용
await orm.em.begin(); // 다른 요청과 충돌 가능

// ✅ 안전: fork된 em 사용
const em = orm.em.fork();
await em.begin();

await em.transactional(async (em1) => {
  const author = new Author('Kim');
  em1.persist(author);

  try {
    await em1.transactional(async (em2) => {
      const book = new Book('Draft');
      em2.persist(book);
      throw new Error('내부 실패');
    });
  } catch (e) {
    // 내부 트랜잭션만 롤백됨 (savepoint까지)
    // author는 여전히 저장됨
  }
});

@Transactional()
async createAuthorWithBook() {
  const author = new Author('Martin');
  this.em.persist(author);
  await this.addBook(author);
}

@Transactional({ propagation: TransactionPropagation.REQUIRED })
async addBook(author: Author) {
  const book = new Book('Clean Code');
  book.author = author;
  this.em.persist(book);
  throw new Error(); // author와 book 모두 롤백!
}

@Transactional()
async processOrder() {
  const order = new Order();
  this.em.persist(order);

  await this.logAudit('ORDER_CREATED'); // 독립 트랜잭션

  throw new Error(); // order는 롤백, 하지만 audit log는 이미 커밋됨
}

@Transactional({ propagation: TransactionPropagation.REQUIRES_NEW })
async logAudit(action: string) {
  const log = new AuditLog(action);
  this.em.persist(log);
  // 여기서 독립적으로 커밋됨
}

@Transactional({ propagation: TransactionPropagation.MANDATORY })
async deductStock(productId: number, qty: number) {
  const product = await this.em.findOneOrFail(Product, productId);
  product.stock -= qty;
}

// ✅ 트랜잭션 안에서 호출 → 정상
await em.transactional(async () => {
  await stockService.deductStock(1, 5);
});

// ❌ 트랜잭션 없이 호출 → ValidationError!
await stockService.deductStock(1, 5);

@Transactional({ propagation: TransactionPropagation.SUPPORTS })
async findBook(id: number) {
  return this.em.findOneOrFail(Book, id, { populate: ['author'] });
}

import { IsolationLevel } from '@mikro-orm/core';

await em.transactional(async (em) => {
  const product = await em.findOneOrFail(Product, productId);
  product.stock -= 1;
}, { isolationLevel: IsolationLevel.SERIALIZABLE });

import { FlushMode } from '@mikro-orm/core';

await em.transactional(async (em) => {
  const user = new User('Alice');
  em.persist(user);

  // FlushMode.AUTO: 쿼리 전에 자동 flush
  // FlushMode.COMMIT: 커밋 시에만 flush (기본값)
  // FlushMode.ALWAYS: 모든 쿼리 전에 flush
  const count = await em.count(User); // COMMIT 모드에서는 Alice가 안 잡힘
}, { flushMode: FlushMode.AUTO });

@Injectable()
export class OrderService {
  constructor(
    private readonly em: EntityManager,
    private readonly paymentService: PaymentService,
    private readonly inventoryService: InventoryService,
  ) {}

  @Transactional()
  async placeOrder(dto: CreateOrderDto) {
    // 1. 주문 생성
    const order = new Order(dto.customerId);
    this.em.persist(order);

    // 2. 재고 차감
    for (const item of dto.items) {
      await this.inventoryService.deduct(item.productId, item.quantity);
    }

    // 3. 결제 처리
    await this.paymentService.charge(order.id, dto.amount);

    return order;
  }
}

@Transactional()
async transferBalance(fromId: number, toId: number, amount: number) {
  const from = await this.em.findOneOrFail(Account, fromId);
  const to = await this.em.findOneOrFail(Account, toId);

  if (from.balance < amount) {
    throw new BadRequestException('잔액 부족');
  }

  from.balance -= amount;
  to.balance += amount;

  // 이체 기록
  const transfer = new TransferLog(from, to, amount);
  this.em.persist(transfer);
}

// ❌ 나쁜 예: 트랜잭션 안에서 외부 API 호출
@Transactional()
async processPayment(orderId: number) {
  const order = await this.em.findOneOrFail(Order, orderId);
  order.status = OrderStatus.PAID;

  // 외부 결제 API 호출 - 응답이 느리면 트랜잭션이 오래 열려있음
  await this.stripeClient.charge(order.amount);
}

// ✅ 좋은 예: 외부 호출은 트랜잭션 밖에서
async processPayment(orderId: number) {
  // 1. 외부 결제 먼저
  const charge = await this.stripeClient.charge(amount);

  // 2. 성공하면 DB 업데이트 (트랜잭션은 짧게)
  await this.em.transactional(async (em) => {
    const order = await em.findOneOrFail(Order, orderId);
    order.status = OrderStatus.PAID;
    order.chargeId = charge.id;
  });
}

await em.transactional(async (em) => {
  // nativeUpdate는 Unit of Work를 우회한다
  await em.nativeUpdate(User, { id: 1 }, { name: 'New' });
  // 이 쿼리는 즉시 실행됨. flush를 기다리지 않음
});

await em.transactional(async (em) => {
  em.persist(entity1);
  await em.flush(); // 쿼리 실행, 하지만 아직 커밋 아님
  
  em.persist(entity2);
  // 콜백 종료 → 자동 flush + commit
});