트랜잭션 관리와 데이터 정합성

import { Injectable } from '@nestjs/common';
import { DataSource, Repository } from 'typeorm'; // DataSource 임포트
import { InjectRepository } from '@nestjs/typeorm';
import { Product } from '../product/entities/product.entity';
import { Order } from './entities/order.entity';
import { OrderItem } from './entities/order-item.entity';

@Injectable()
export class OrderService {
  constructor(
    private dataSource: DataSource, // DataSource 주입
    @InjectRepository(Product)
    private productRepository: Repository<Product>,
    @InjectRepository(Order)
    private orderRepository: Repository<Order>,
    @InjectRepository(OrderItem)
    private orderItemRepository: Repository<OrderItem>,
  ) {}

  async createOrder(userId: number, productIds: number[]): Promise<Order> {
    // 트랜잭션 시작
    return this.dataSource.transaction(async (manager) => {
      // manager를 통해 트랜잭션 스코프 내의 Repository를 사용합니다.
      const productRepo = manager.getRepository(Product);
      const orderRepo = manager.getRepository(Order);
      const orderItemRepo = manager.getRepository(OrderItem);

      // 1. 주문 생성
      const order = orderRepo.create({ userId, orderDate: new Date() });
      await orderRepo.save(order);

      // 2. 각 상품에 대한 주문 아이템 생성 및 재고 감소
      for (const productId of productIds) {
        const product = await productRepo.findOneBy({ id: productId });

        if (!product || product.stock <= 0) {
          // 재고가 없거나 상품이 존재하지 않으면 트랜잭션 롤백
          throw new Error(`Product with ID ${productId} is out of stock or not found.`);
        }

        product.stock -= 1; // 재고 감소
        await productRepo.save(product); // 상품 업데이트

        const orderItem = orderItemRepo.create({
          order,
          productId: product.id,
          quantity: 1,
          price: product.price,
        });
        await orderItemRepo.save(orderItem); // 주문 아이템 저장
      }

      return order; // 모든 작업 성공 시 자동 커밋
    }); // 트랜잭션 블록 끝
  }
}

// (이 방법은 필요할 때만 사용하며, 위 방법이 더 일반적입니다.)
import { QueryRunner } from 'typeorm';

async complexTransaction(): Promise<void> {
  const queryRunner = this.dataSource.createQueryRunner();
  await queryRunner.connect();
  await queryRunner.startTransaction();

  try {
    // queryRunner.manager를 통해 작업 수행
    await queryRunner.manager.save(SomeEntity, someData);
    await queryRunner.manager.update(AnotherEntity, { id: 1 }, { status: 'completed' });

    await queryRunner.commitTransaction(); // 성공 시 커밋
  } catch (err) {
    await queryRunner.rollbackTransaction(); // 실패 시 롤백
  } finally {
    await queryRunner.release(); // queryRunner 해제
  }
}

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service'; // PrismaService 임포트
import { Prisma, Order, OrderItem, Product } from '@prisma/client'; // Prisma Client에서 생성된 타입 임포트

@Injectable()
export class OrderService {
  constructor(private prisma: PrismaService) {}

  async createOrder(userId: number, productIds: number[]): Promise<Order> {
    // 상호작용적 트랜잭션 시작
    return this.prisma.$transaction(async (tx) => {
      // 'tx'는 트랜잭션 클라이언트입니다. 모든 쿼리는 'tx'를 통해 실행됩니다.

      // 1. 주문 생성
      const order = await tx.order.create({
        data: {
          userId,
          orderDate: new Date(),
        },
      });

      // 2. 각 상품에 대한 주문 아이템 생성 및 재고 감소
      for (const productId of productIds) {
        const product = await tx.product.findUnique({
          where: { id: productId },
        });

        if (!product || product.stock <= 0) {
          // 재고가 없거나 상품이 존재하지 않으면 트랜잭션 롤백
          throw new Error(`Product with ID ${productId} is out of stock or not found.`);
        }

        await tx.product.update({
          where: { id: productId },
          data: { stock: product.stock - 1 }, // 재고 감소
        });

        await tx.orderItem.create({
          data: {
            orderId: order.id,
            productId: product.id,
            quantity: 1,
            price: product.price,
          },
        });
      }

      return order; // 모든 작업 성공 시 자동 커밋
    }); // 트랜잭션 블록 끝
  }
}

// 여러 업데이트/삭제 작업을 묶을 때
async updateMultipleUsersStatus(ids: number[], newStatus: boolean): Promise<any> {
  const queries = ids.map(id =>
    this.prisma.user.update({
      where: { id },
      data: { isActive: newStatus },
    })
  );
  return this.prisma.$transaction(queries); // 모든 쿼리가 성공해야 커밋
}