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

import { Injectable } from '@nestjs/common';
import { DataSource } from '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 readonly dataSource: DataSource) {}

  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 changed = await productRepo
          .createQueryBuilder()
          .update()
          .set({ stock: () => 'stock - 1' })
          .where('id = :productId', { productId })
          .andWhere('stock > 0')
          .execute();

        if (changed.affected !== 1) {
          throw new Error(`Product with ID ${productId} is out of stock or not found.`);
        }

        const product = await productRepo.findOneByOrFail({ id: productId });

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

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

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(); // 실패 시 롤백
    throw err; // 실패를 성공으로 숨기지 않음
  } finally {
    await queryRunner.release(); // queryRunner 해제
  }
}

import { Injectable } from '@nestjs/common';
import { Order, Prisma } from '../generated/prisma/client';
import { PrismaService } from '../prisma/prisma.service';

function isP2034(error: unknown): boolean {
  return (
    typeof error === 'object' &&
    error !== null &&
    'code' in error &&
    (error as { code?: unknown }).code === 'P2034'
  );
}

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

  private async withSerializableRetry<T>(
    work: (tx: Prisma.TransactionClient) => Promise<T>,
  ): Promise<T> {
    const maxAttempts = 3;

    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
      try {
        return await this.prisma.$transaction(work, {
          isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
        });
      } catch (error) {
        if (!isP2034(error) || attempt === maxAttempts) throw error;
        await new Promise((resolve) => setTimeout(resolve, attempt * 50));
      }
    }

    throw new Error('unreachable');
  }

  async createOrder(userId: number, productIds: number[]): Promise<Order> {
    return this.withSerializableRetry(async (tx) => {
      const order = await tx.order.create({
        data: { userId, orderDate: new Date() },
      });

      for (const productId of productIds) {
        const changed = await tx.product.updateMany({
          where: { id: productId, stock: { gte: 1 } },
          data: { stock: { decrement: 1 } },
        });

        if (changed.count !== 1) {
          throw new Error(`Product with ID ${productId} is out of stock or not found.`);
        }

        const product = await tx.product.findUniqueOrThrow({
          where: { id: productId },
          select: { id: true, price: true },
        });

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

      return order;
    });
  }
}

async updateMultipleUsersStatus(ids: number[], isActive: boolean) {
  const queries = ids.map((id) =>
    this.prisma.user.update({
      where: { id },
      data: { isActive },
    }),
  );

  return this.prisma.$transaction(queries);
}