트랜잭션 생명주기 훅의 효용과 활용 방안 (w/ NodeJS + TypeORM)

서론

백엔드 애플리케이션에서 트랜잭션 관리는 데이터 일관성을 유지하는 핵심 요소입니다. Node.js 환경에서 TypeORM을 사용할 때, 우리는 기본적인 트랜잭션 기능을 쉽게 사용할 수 있습니다. 그러나 애플리케이션이 복잡해질수록, 단순한 데이터베이스 트랜잭션 이상의 것이 필요해집니다.

현대 애플리케이션에서는 데이터베이스 작업과 함께 웹소켓 통신, 푸시 알림, 외부 API 호출 등 다양한 부가 작업이 필요합니다. 이러한 작업들은 DB 트랜잭션 성공 여부에 따라 실행 여부가 결정되는 경우가 많습니다. TypeORM의 기본 트랜잭션 API만으로는 이러한 복잡한 흐름을 우아하게 처리하기 어렵습니다.

이 글에서는 TypeORM 환경에서 트랜잭션 생명주기 훅을 활용해 횡단 관심사를 효과적으로 처리하는 방법에 대해 알아보겠습니다. 다른 언어와 프레임워크에서 제공하는 트랜잭션 훅과 비교하고, Node.js + TypeORM 환경에서 이를 적용해보는 방법을 살펴보겠습니다.

본론

1. 트랜잭션 관리의 도전 과제

비즈니스 로직과 트랜잭션 로직의 결합

TypeORM에서 기본적인 트랜잭션 사용은 아래와 같이 구현합니다:

await dataSource.transaction(async transactionalEntityManager => {
  await transactionalEntityManager.save(user);
  await transactionalEntityManager.save(userProfile);
});

이 패턴은 단순한 경우에는 잘 작동하지만, 다음과 같은 문제에 직면하게 됩니다:

1. 비즈니스 로직과 트랜잭션 처리 로직이 결합됨: 트랜잭션 관리 코드가 비즈니스 로직과 섞여 가독성과 유지보수성이 저하됩니다.

2. 코드 중복: 여러 서비스에서 유사한 트랜잭션 처리 패턴이 반복됩니다.

3. 횡단 관심사 처리의 어려움: 트랜잭션 성공/실패 시 실행되어야 하는 추가 로직을 일관되게 처리하기 어렵습니다.

실제 NestJS에서 트랜잭션을 사용한 코드를 살펴보면 이런 문제가 명확히 드러납니다:

// 기본적인 트랜잭션 처리 방식
async createOrder({ itemsToOrder }: CreateOrderRequestDto): Promise<Order> {
  const queryRunner = this.dataSource.createQueryRunner();
  await queryRunner.connect();
  await queryRunner.startTransaction();

  try {
    const order = await queryRunner.manager.save(Order.create({...}));
    await queryRunner.manager.save(itemsToOrder.map(item => OrderItem.create({...})));
    await queryRunner.commitTransaction();

    // 트랜잭션 성공 후 알림 발송 (DB 외 로직)
    await this.notificationService.sendOrderCreatedNotification(order);

    return order;
  } catch (e) {
    await queryRunner.rollbackTransaction();
    throw new InternalServerErrorException();
  } finally {
    await queryRunner.release();
  }
}

이 코드에서는 트랜잭션이 성공한 후에만 알림을 보내는 로직이 있습니다. 이러한 패턴이 여러 서비스에 걸쳐 반복되면 코드 관리가 어려워지고, 트랜잭션 성공/실패에 따른 부가 로직 처리가 일관되지 않을 위험이 있습니다.

DB 외 로직 처리의 도전

트랜잭션이 성공한 후에 실행되어야 하는 로직들을 생각해 보세요:

• 이메일 또는 푸시 알림 발송

• 웹소켓을 통한 실시간 업데이트

• 캐시 무효화

• 외부 서비스 API 호출

• 로깅 및 감사

이런 로직들은 트랜잭션 성공 후에만 실행되어야 하며, 트랜잭션이 실패할 경우 실행되면 안 됩니다. 기본 TypeORM 트랜잭션 API만으로는 이런 패턴을 우아하게 구현하기 어렵습니다.

2. 다른 환경의 트랜잭션 생명주기 훅

다른 프레임워크나 ORM에서는 이러한 문제를 어떻게 해결하고 있을까요?

Java Spring의 트랜잭션 동기화

Spring 프레임워크에서는 TransactionSynchronizationManager를 통해 트랜잭션 생명주기 이벤트를 처리할 수 있습니다:

@Transactional
public void createUser(User user) {
    userRepository.save(user);

    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
        @Override
        public void afterCommit() {
            emailService.sendWelcomeEmail(user.getEmail());
        }
    });
}

이 코드는 트랜잭션이 성공적으로 커밋된 후에만 이메일을 보냅니다. Spring 4.2부터는 애노테이션 기반 이벤트 핸들링도 지원합니다.

Sequelize의 트랜잭션 훅

Sequelize는 트랜잭션 훅을 직접 지원합니다:

const transaction = await sequelize.transaction({
  hooks: {
    afterCommit: async (tx) => {
      await notificationService.send('Transaction completed');
    },
    afterRollback: async (tx) => {
      console.log('Transaction rolled back');
    }
  }
});

이러한 훅은 트랜잭션의 생명주기 이벤트에 반응할 수 있게 해주어 횡단 관심사를 깔끔하게의 처리할 수 있습니다.

이처럼 다른 언어와 프레임워크에서는 트랜잭션 생명주기 이벤트를 처리하기 위한 다양한 메커니즘을 제공하고 있습니다.

3. TypeORM에서의 트랜잭션 생명주기 훅 구현

TypeORM은 기본적으로 트랜잭션 생명주기 훅을 제공하지 않지만, 커뮤니티에서 개발한 라이브러리를 활용하거나 직접 구현할 수 있습니다.

typeorm-transactional 라이브러리 활용

typeorm-transactional은 TypeORM에서 트랜잭션을 더 편리하게 사용할 수 있게 해주는 라이브러리입니다. 이 라이브러리는 @Transactional() 데코레이터를 제공하며, 트랜잭션 콜백을 지원합니다.

트랜잭션 훅 사용:

import { Transactional, runOnTransactionCommit, runOnTransactionRollback } from 'typeorm-transactional';

export class UserService {
  constructor(
    private userRepository: UserRepository,
    private emailService: EmailService,
    private logService: LogService
  ) {}

  @Transactional()
  async createUser(userData: CreateUserDto): Promise<User> {
    const user = await this.userRepository.save(userData);

    // 트랜잭션 커밋 후 실행될 로직 등록
    runOnTransactionCommit(async () => {
      await this.emailService.sendWelcomeEmail(user.email);
      console.log('User created successfully');
    });

    // 트랜잭션 롤백 시 실행될 로직 등록
    runOnTransactionRollback(async () => {
      await this.logService.logFailure('User creation failed');
    });

    return user;
  }
}

이 코드에서는 @Transactional() 데코레이터로 메서드를 감싸고, runOnTransactionCommit과 runOnTransactionRollback 함수를 사용하여 트랜잭션 생명주기 이벤트에 반응하는 코드를 등록합니다.

4. 실전 예제: 멀티 도메인 서비스에서의 트랜잭션 훅 활용 (w/ typeorm-transactional)

복잡한 비즈니스 로직을 가진 주문 생성 API를 예로 들어보겠습니다:

@Injectable()
export class OrderService {
  constructor(
    private orderRepository: OrderRepository,
    private paymentService: PaymentService,
    private inventoryService: InventoryService,
    private notificationService: NotificationService,
    private socketService: SocketService
  ) {}

  @Transactional()
  async createOrder(orderData: CreateOrderDto): Promise<Order> {
    // 1. 주문 생성
    const order = await this.orderRepository.save(new Order(orderData));

    // 2. 결제 처리
    await this.paymentService.processPayment(order.id, orderData.paymentInfo);

    // 3. 재고 감소
    await this.inventoryService.decreaseStock(orderData.items);

    // 트랜잭션 커밋 후 실행될 로직 등록
    runOnTransactionCommit(async () => {
      // 푸시 알림 발송
      await this.notificationService.sendOrderConfirmation(order);

      // 웹소켓으로 실시간 업데이트
      this.socketService.emitOrderCreated(order.userId, order);

      // 외부 물류 시스템 API 호출
      await this.logisticsService.requestShipment(order);
    });

    // 트랜잭션 롤백 시 실행될 로직 등록
    runOnTransactionRollback(async () => {
      // 실패 로깅
      await this.logService.logOrderFailure(orderData, 'Transaction failed');

      // 사용자에게 실패 알림
      await this.notificationService.sendOrderFailureNotice(orderData.userId);
    });

    return order;
  }
}

이 예제에서는:

1. 주문 생성, 결제 처리, 재고 감소가 하나의 트랜잭션 안에서 실행됩니다.

2. 트랜잭션이 성공적으로 커밋된 후에만 알림 발송, 웹소켓 메시지 전송, 외부 API 호출이 실행됩니다.

3. 트랜잭션이 실패하면 롤백 후 실패 로깅과 실패 알림이 발송됩니다.

이 방식은 여러 도메인 서비스에 걸친 복잡한 비즈니스 로직을 처리하면서도, DB 트랜잭션과 DB 외 로직을 명확히 분리하여 관리할 수 있게 해줍니다.

결론

TypeORM 환경에서 트랜잭션 생명주기 훅을 활용한 횡단 관심사 처리는 코드의 가독성, 유지보수성, 재사용성을 크게 향상시킵니다. 특히 다음과 같은 이점이 있습니다:

1. 관심사 분리: DB 트랜잭션 로직과 DB 외 로직(웹소켓, 알림 등)을 명확히 분리할 수 있습니다.

2. 코드 재사용성: 트랜잭션 성공/실패에 따른 로직을 일관되게 처리할 수 있습니다.

3. 가독성 향상: 복잡한 트랜잭션 관리 코드가 @Transactional() 데코레이터로 간소화됩니다.

4. 유지보수성 개선: 트랜잭션 관련 로직이 중앙화되어 변경이 용이합니다.

Spring, Sequelize 등 다른 프레임워크에서 이미 제공하는 트랜잭션 생명주기 훅 기능을 TypeORM 환경에서도 typeorm-transactional 같은 라이브러리를 통해 구현할 수 있습니다. 이는 특히 마이크로서비스 아키텍처나 복잡한 도메인 로직을 가진 애플리케이션에서 큰 가치를 발휘합니다. 따라서 만약 이미 트랜잭션 훅을 지원한다면 위와 같이 적용해보는 것을, 지원하지 않는 환경이라면 직접 구현해서 사용하는 것을 추천합니다.