DDD 이론 2: 유비쿼터스 언어

좋은 도메인 코드는 도메인 전문가가 읽고 비즈니스 로직을 검증할 수 있어야 합니다. 주석이 아니라 코드 자체가 비즈니스 규칙을 설명해야 합니다.

// 도메인 전문가도 이해할 수 있는 비즈니스 로직
class Order {
  
  void cancel(CancellationReason reason) {
    // "배송된 주문은 취소할 수 없다"
    if (this.status.isShipped()) {
      throw new CannotCancelShippedOrder();
    }
    
    // "취소 사유를 기록한다"
    this.cancellationReason = reason;
    
    // "주문 상태를 '취소됨'으로 변경한다"
    this.status = OrderStatus.CANCELLED;
    
    // "환불 정책에 따라 환불 금액을 계산한다"
    Money refundAmount = this.refundPolicy
        .calculateRefundFor(this);
    
    // "주문 취소 이벤트를 발행한다"
    this.registerEvent(new OrderCancelled(
        this.id, 
        reason, 
        refundAmount,
        this.cancelledAt
    ));
  }
  
  // 도메인 전문가의 언어로 된 쿼리 메서드
  boolean canBeCancelled() {
    return !this.status.isShipped() 
        && !this.status.isDelivered();
  }
  
  boolean isEligibleForFullRefund() {
    return this.status.isBeforeShipping();
  }
}

테스트 코드는 도메인 행위의 명세서 역할을 합니다. 테스트 이름과 구조도 유비쿼터스 언어를 따라야 합니다.

// BDD 스타일: Given-When-Then이 도메인 언어로 표현됨
describe('주문 취소', () => {
  it('배송 전 주문은 취소할 수 있다', () => {
    // Given: 결제 완료된 주문이 있다
    const order = OrderFixture.paidOrder();
    
    // When: 고객이 주문을 취소한다
    order.cancel(CancellationReason.CUSTOMER_REQUEST);
    
    // Then: 주문 상태가 '취소됨'이 된다
    expect(order.status).toBe(OrderStatus.CANCELLED);
    
    // And: 전액 환불이 요청된다
    expect(order.domainEvents).toContainEqual(
      expect.objectContaining({
        type: 'OrderCancelled',
        refundAmount: order.totalAmount
      })
    );
  });

  it('배송된 주문은 취소할 수 없다', () => {
    // Given: 배송 중인 주문이 있다
    const order = OrderFixture.shippedOrder();
    
    // When & Then: 취소 시도하면 예외가 발생한다
    expect(() => {
      order.cancel(CancellationReason.CUSTOMER_REQUEST);
    }).toThrow(CannotCancelShippedOrder);
  });
});

// 용어집이 그대로 코드가 됨
abstract class Book {
  readonly bookId: BookId;
  readonly title: string;
  readonly author: Author;
  readonly price: Money;
  readonly publisher: Publisher;
  
  abstract getBookType(): BookType;
}

class PaperBook extends Book {
  readonly isbn: ISBN;
  
  getBookType(): BookType {
    return BookType.PAPER;
  }
}

class EBook extends Book {
  readonly fileFormat: FileFormat;
  readonly downloadUrl: string;
  
  getBookType(): BookType {
    return BookType.EBOOK;
  }
}

// 재고는 종이책에만 적용
class Stock {
  readonly bookId: BookId;  // PaperBook만 해당
  private quantity: number;
  
  receive(amount: number): void {  // 입고
    this.quantity += amount;
    this.registerEvent(new StockReceived(this.bookId, amount));
  }
  
  release(amount: number): void {  // 출고
    if (this.quantity < amount) {
      throw new InsufficientStock(this.bookId);
    }
    this.quantity -= amount;
    this.registerEvent(new StockReleased(this.bookId, amount));
  }
}

서로 다른 Context가 통신할 때는 명시적인 번역이 필요합니다. 이것이 Anti-Corruption Layer의 역할입니다.

// 주문 Context에서 결제 Context로 요청할 때
class PaymentAntiCorruptionLayer {
  
  constructor(private paymentService: PaymentService) {}
  
  // 주문 Context의 언어 → 결제 Context의 언어로 번역
  requestPayment(customer: Customer, order: Order): PaymentResult {
    // Customer → Payer로 번역
    const payer = this.translateToPayer(customer);
    
    // Order → PaymentRequest로 번역
    const paymentRequest = this.translateToPaymentRequest(order);
    
    // 결제 Context의 언어로 호출
    return this.paymentService.processPayment(payer, paymentRequest);
  }
  
  private translateToPayer(customer: Customer): Payer {
    return new Payer(
      PayerId.from(customer.customerId),
      customer.defaultPaymentMethod
    );
  }
  
  private translateToPaymentRequest(order: Order): PaymentRequest {
    return new PaymentRequest(
      order.orderId.toString(),
      order.totalAmount,
      order.currency
    );
  }
}