DDD 이론 4: Bounded Context 심화

// 1. 도메인 인터페이스 (우리 언어로 정의)
interface PaymentGateway {
  processPayment(payment: Payment): Promise<PaymentResult>;
  refund(paymentId: PaymentId, amount: Money): Promise<RefundResult>;
  getPaymentStatus(paymentId: PaymentId): Promise<PaymentStatus>;
}

// 2. 외부 시스템의 모델 (Stripe API)
interface StripeChargeRequest {
  amount: number;           // cents 단위
  currency: string;
  source: string;
  metadata: Record<string, string>;
  capture: boolean;
}

interface StripeChargeResponse {
  id: string;
  status: 'succeeded' | 'pending' | 'failed';
  amount: number;
  created: number;          // Unix timestamp
  failure_code?: string;
  failure_message?: string;
}

// 3. ACL - Translator (모델 변환)
class StripePaymentTranslator {
  toStripeRequest(payment: Payment): StripeChargeRequest {
    return {
      amount: payment.amount.toCents(),  // Money → cents
      currency: payment.amount.currency.toLowerCase(),
      source: payment.paymentMethod.token,
      metadata: {
        orderId: payment.orderId.value,
        customerId: payment.customerId.value
      },
      capture: true
    };
  }
  
  toPaymentResult(response: StripeChargeResponse): PaymentResult {
    return new PaymentResult({
      paymentId: new PaymentId(response.id),
      status: this.mapStatus(response.status),
      processedAt: new Date(response.created * 1000),
      failureReason: response.failure_message 
        ? new PaymentFailure(response.failure_code!, response.failure_message)
        : undefined
    });
  }
  
  private mapStatus(stripeStatus: string): PaymentStatus {
    const mapping: Record<string, PaymentStatus> = {
      'succeeded': PaymentStatus.COMPLETED,
      'pending': PaymentStatus.PENDING,
      'failed': PaymentStatus.FAILED
    };
    return mapping[stripeStatus] ?? PaymentStatus.UNKNOWN;
  }
}

// 4. ACL - Adapter (프로토콜 변환)
class StripePaymentAdapter implements PaymentGateway {
  constructor(
    private stripeClient: StripeClient,
    private translator: StripePaymentTranslator,
    private logger: Logger
  ) {}
  
  async processPayment(payment: Payment): Promise<PaymentResult> {
    try {
      // 우리 모델 → Stripe 모델
      const stripeRequest = this.translator.toStripeRequest(payment);
      
      // 외부 API 호출
      const stripeResponse = await this.stripeClient.charges.create(stripeRequest);
      
      // Stripe 모델 → 우리 모델
      return this.translator.toPaymentResult(stripeResponse);
      
    } catch (error) {
      // 외부 에러 → 도메인 에러로 변환
      this.logger.error('Stripe payment failed', { error, payment });
      throw this.translateError(error);
    }
  }
  
  private translateError(error: unknown): PaymentError {
    if (error instanceof StripeCardError) {
      return new CardDeclinedError(error.decline_code);
    }
    if (error instanceof StripeRateLimitError) {
      return new PaymentServiceUnavailableError();
    }
    return new PaymentProcessingError('Unknown payment error');
  }
}

// 5. 도메인 서비스에서 사용
class PaymentService {
  constructor(private paymentGateway: PaymentGateway) {}  // 인터페이스에 의존
  
  async processOrderPayment(order: Order): Promise<PaymentResult> {
    const payment = Payment.createForOrder(order);
    
    // ACL을 통해 외부 시스템과 통신
    // 도메인 코드는 Stripe를 전혀 모름
    const result = await this.paymentGateway.processPayment(payment);
    
    if (result.isSuccessful()) {
      order.markAsPaid(result.paymentId);
    }
    
    return result;
  }
}

class ResilientPaymentAdapter implements PaymentGateway {
  constructor(
    private stripeClient: StripeClient,
    private translator: StripePaymentTranslator,
    private circuitBreaker: CircuitBreaker,
    private retryPolicy: RetryPolicy
  ) {}
  
  async processPayment(payment: Payment): Promise<PaymentResult> {
    // Circuit Breaker로 감싸기
    return this.circuitBreaker.execute(async () => {
      // Retry 정책 적용
      return this.retryPolicy.execute(async () => {
        const request = this.translator.toStripeRequest(payment);
        const response = await this.stripeClient.charges.create(request);
        return this.translator.toPaymentResult(response);
      });
    }, {
      // Fallback: Circuit이 열렸을 때
      fallback: () => {
        return PaymentResult.deferred(payment.id, 'Payment service temporarily unavailable');
      }
    });
  }
}

Strangler Fig(교살자 무화과)는 숙주 나무를 감싸며 자라다가 결국 대체하는 식물입니다. 이 패턴은 레거시 시스템을 점진적으로 새 시스템으로 교체합니다.

Phase 1: Facade 도입
┌─────────────────────────────────────────────────────┐
│                    API Gateway                       │
│                    (Facade)                          │
└─────────────────────────────────────────────────────┘
                        │
                        │ 100% 트래픽
                        ▼
┌─────────────────────────────────────────────────────┐
│                  Legacy Monolith                     │
└─────────────────────────────────────────────────────┘

Phase 2: 새 Context 추가
┌─────────────────────────────────────────────────────┐
│                    API Gateway                       │
└─────────────────────────────────────────────────────┘
           │                              │
           │ /orders/*                    │ 나머지
           ▼                              ▼
┌─────────────────┐            ┌─────────────────────┐
│  New Order      │            │   Legacy Monolith   │
│  Context        │───ACL────►│                     │
└─────────────────┘            └─────────────────────┘

Phase 3: 점진적 마이그레이션
┌─────────────────────────────────────────────────────┐
│                    API Gateway                       │
└─────────────────────────────────────────────────────┘
     │              │              │              │
     ▼              ▼              ▼              ▼
┌────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ Order  │   │ Inventory│   │ Payment  │   │ Legacy   │
│Context │   │ Context  │   │ Context  │   │(축소중)   │
└────────┘   └──────────┘   └──────────┘   └──────────┘

Phase 4: 완료
┌─────────────────────────────────────────────────────┐
│                    API Gateway                       │
└─────────────────────────────────────────────────────┘
     │              │              │              │
     ▼              ▼              ▼              ▼
┌────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ Order  │   │ Inventory│   │ Payment  │   │ Shipping │
│Context │   │ Context  │   │ Context  │   │ Context  │
└────────┘   └──────────┘   └──────────┘   └──────────┘
                    Legacy 제거 완료

• • 고객은 객실을 검색하고 예약할 수 있다
• • 예약 시 결제가 처리되어야 한다
• • 객실 가용성이 실시간으로 관리되어야 한다
• • 고객에게 예약 확인 알림이 발송되어야 한다
• • 멤버십 등급에 따른 할인이 적용된다
• • 체크인/체크아웃 프로세스가 관리되어야 한다
• • 하우스키핑 일정이 관리되어야 한다

// Reservation Context - 예약 생성
class ReservationService {
  constructor(
    private roomAvailabilityClient: RoomAvailabilityClient,  // ACL
    private guestClient: GuestClient,                        // ACL
    private eventPublisher: DomainEventPublisher
  ) {}
  
  async createReservation(command: CreateReservationCommand): Promise<Reservation> {
    // 1. 객실 가용성 확인 (동기 - Room Context)
    const availability = await this.roomAvailabilityClient.checkAvailability({
      roomType: command.roomType,
      checkIn: command.checkIn,
      checkOut: command.checkOut
    });
    
    if (!availability.isAvailable) {
      throw new RoomNotAvailableError(command.roomType, command.checkIn);
    }
    
    // 2. 고객 정보 조회 (동기 - Guest Context)
    const guest = await this.guestClient.getGuest(command.guestId);
    
    // 3. 가격 계산 (멤버십 할인 적용)
    const pricing = this.calculatePricing(
      availability.room,
      command.checkIn,
      command.checkOut,
      guest.membership
    );
    
    // 4. 예약 생성
    const reservation = Reservation.create({
      guestId: command.guestId,
      roomId: availability.room.id,
      checkIn: command.checkIn,
      checkOut: command.checkOut,
      totalAmount: pricing.total,
      status: ReservationStatus.PENDING
    });
    
    // 5. 도메인 이벤트 등록
    reservation.addDomainEvent(new ReservationCreatedEvent({
      reservationId: reservation.id,
      guestId: reservation.guestId,
      roomId: reservation.roomId,
      checkIn: reservation.checkIn,
      checkOut: reservation.checkOut,
      totalAmount: reservation.totalAmount
    }));
    
    await this.reservationRepository.save(reservation);
    await this.eventPublisher.publishAll(reservation.domainEvents);
    
    return reservation;
  }
}

// Payment Context - 이벤트 핸들러
@EventHandler(ReservationCreatedEvent)
class ProcessPaymentHandler {
  async handle(event: ReservationCreatedEvent): Promise<void> {
    // 결제 처리 시작
    const payment = await this.paymentService.initiatePayment({
      reservationId: event.reservationId,
      amount: event.totalAmount,
      guestId: event.guestId
    });
    
    // 결제 완료 이벤트 발행
    await this.eventPublisher.publish(new PaymentCompletedEvent({
      paymentId: payment.id,
      reservationId: event.reservationId
    }));
  }
}

// Room Context - 이벤트 핸들러
@EventHandler(PaymentCompletedEvent)
class BlockRoomHandler {
  async handle(event: PaymentCompletedEvent): Promise<void> {
    const reservation = await this.reservationClient
      .getReservation(event.reservationId);
    
    // 객실 예약 블록
    await this.roomService.blockRoom({
      roomId: reservation.roomId,
      checkIn: reservation.checkIn,
      checkOut: reservation.checkOut,
      reservationId: reservation.id
    });
  }
}

// Notification Context - 이벤트 핸들러
@EventHandler(PaymentCompletedEvent)
class SendConfirmationHandler {
  async handle(event: PaymentCompletedEvent): Promise<void> {
    const reservation = await this.reservationClient
      .getReservation(event.reservationId);
    const guest = await this.guestClient.getGuest(reservation.guestId);
    
    await this.notificationService.send({
      recipientId: guest.id,
      channel: NotificationChannel.EMAIL,
      template: 'reservation-confirmation',
      data: {
        guestName: guest.profile.name,
        reservationId: reservation.id,
        checkIn: reservation.checkIn,
        checkOut: reservation.checkOut,
        roomType: reservation.roomType
      }
    });
  }
}