DDD 이론 7: Aggregate 설계 심화

class Order extends AggregateRoot<OrderId> {
  private _customerId: CustomerId;
  private _items: OrderLineItem[];
  private _status: OrderStatus;
  private _shippingAddress: Address;
  private _discount: Discount | null;
  private _totalAmount: Money;

  // Private 생성자 - 팩토리 메서드 사용 강제
  private constructor(id: OrderId) {
    super(id);
    this._items = [];
    this._status = OrderStatus.DRAFT;
    this._totalAmount = Money.zero();
    this._discount = null;
  }

  // 팩토리 메서드: 새 Aggregate 생성
  static create(customerId: CustomerId, shippingAddress: Address): Order {
    const order = new Order(OrderId.generate());
    order._customerId = customerId;
    order._shippingAddress = shippingAddress;
    
    // 도메인 이벤트 발행
    order.addDomainEvent(new OrderCreatedEvent(order.id, customerId));
    
    return order;
  }

  // 재구성: Repository에서 로드
  static reconstitute(props: OrderProps): Order {
    const order = new Order(props.id);
    order._customerId = props.customerId;
    order._items = props.items;
    order._status = props.status;
    order._shippingAddress = props.shippingAddress;
    order._discount = props.discount;
    order._totalAmount = props.totalAmount;
    order._version = props.version;
    return order;
  }

  // ========== 명령 메서드 (Command Methods) ==========

  addItem(productId: ProductId, productName: string, 
          quantity: Quantity, unitPrice: Money): void {
    this.ensureModifiable();
    
    // 기존 항목 확인
    const existingItem = this._items.find(
      item => item.productId.equals(productId)
    );
    
    if (existingItem) {
      // 기존 항목 수량 증가
      const newQuantity = existingItem.quantity.add(quantity);
      this.updateItemQuantity(existingItem.lineNumber, newQuantity);
    } else {
      // 새 항목 추가
      const lineNumber = this.nextLineNumber();
      const item = OrderLineItem.create(
        lineNumber, productId, productName, quantity, unitPrice
      );
      this._items.push(item);
      this.recalculateTotal();
      
      this.addDomainEvent(new OrderItemAddedEvent(this.id, item));
    }
  }

  removeItem(lineNumber: number): void {
    this.ensureModifiable();
    
    const index = this._items.findIndex(
      item => item.lineNumber === lineNumber
    );
    
    if (index === -1) {
      throw new OrderItemNotFoundError(lineNumber);
    }
    
    const removed = this._items.splice(index, 1)[0];
    this.recalculateTotal();
    
    this.addDomainEvent(new OrderItemRemovedEvent(this.id, removed));
  }

  updateItemQuantity(lineNumber: number, quantity: Quantity): void {
    this.ensureModifiable();
    
    const item = this._items.find(i => i.lineNumber === lineNumber);
    if (!item) {
      throw new OrderItemNotFoundError(lineNumber);
    }
    
    // 내부 Entity 수정도 Root를 통해
    const updatedItem = item.withQuantity(quantity);
    const index = this._items.indexOf(item);
    this._items[index] = updatedItem;
    
    this.recalculateTotal();
  }

  applyDiscount(discount: Discount): void {
    this.ensureModifiable();
    
    if (this._discount) {
      throw new DiscountAlreadyAppliedError();
    }
    
    this._discount = discount;
    this.recalculateTotal();
    
    this.addDomainEvent(new DiscountAppliedEvent(this.id, discount));
  }

  confirm(): void {
    this.ensureModifiable();
    
    // 불변식 검증
    if (this._items.length === 0) {
      throw new EmptyOrderError();
    }
    
    if (this._totalAmount.isLessThan(Order.MINIMUM_ORDER_AMOUNT)) {
      throw new MinimumOrderAmountError(Order.MINIMUM_ORDER_AMOUNT);
    }
    
    this._status = OrderStatus.CONFIRMED;
    
    this.addDomainEvent(new OrderConfirmedEvent(this.id, this._totalAmount));
  }

  ship(trackingNumber: TrackingNumber): void {
    if (this._status !== OrderStatus.CONFIRMED) {
      throw new InvalidOrderStateError('Only confirmed orders can be shipped');
    }
    
    this._status = OrderStatus.SHIPPED;
    
    this.addDomainEvent(new OrderShippedEvent(this.id, trackingNumber));
  }

  cancel(reason: CancellationReason): void {
    if (!this._status.canBeCancelled()) {
      throw new OrderCannotBeCancelledError(this._status);
    }
    
    this._status = OrderStatus.CANCELLED;
    
    this.addDomainEvent(new OrderCancelledEvent(this.id, reason));
  }

  // ========== 쿼리 메서드 (Query Methods) ==========

  get customerId(): CustomerId { return this._customerId; }
  get status(): OrderStatus { return this._status; }
  get totalAmount(): Money { return this._totalAmount; }
  get shippingAddress(): Address { return this._shippingAddress; }
  get discount(): Discount | null { return this._discount; }
  
  // 내부 컬렉션은 복사본 반환 (불변성 보호)
  get items(): readonly OrderLineItem[] { 
    return [...this._items]; 
  }

  get itemCount(): number {
    return this._items.length;
  }

  get subtotal(): Money {
    return this._items.reduce(
      (sum, item) => sum.add(item.lineTotal),
      Money.zero()
    );
  }

  // ========== Private 메서드 ==========

  private ensureModifiable(): void {
    if (this._status !== OrderStatus.DRAFT) {
      throw new OrderNotModifiableError(this._status);
    }
  }

  private recalculateTotal(): void {
    const subtotal = this.subtotal;
    const discountAmount = this._discount?.applyTo(subtotal) ?? Money.zero();
    this._totalAmount = subtotal.subtract(discountAmount);
  }

  private nextLineNumber(): number {
    if (this._items.length === 0) return 1;
    return Math.max(...this._items.map(i => i.lineNumber)) + 1;
  }

  // 상수
  private static readonly MINIMUM_ORDER_AMOUNT = Money.won(10000);
}

class Order {
  // 불변식 1: 총액 계산
  private recalculateTotal(): void {
    const subtotal = this._items.reduce(
      (sum, item) => sum.add(item.lineTotal),
      Money.zero()
    );
    const discountAmount = this._discount?.applyTo(subtotal) ?? Money.zero();
    const shippingFee = this.calculateShippingFee(subtotal.subtract(discountAmount));
    
    this._totalAmount = subtotal.subtract(discountAmount).add(shippingFee);
  }

  // 불변식 2: 상태 전이 규칙
  confirm(): void {
    // 전제조건 검증
    this.ensureCanConfirm();
    
    this._status = OrderStatus.CONFIRMED;
    
    // 도메인 이벤트 발행 (최종 일관성 트리거)
    this.addDomainEvent(new OrderConfirmedEvent(
      this.id,
      this._items.map(item => ({
        productId: item.productId,
        quantity: item.quantity
      }))
    ));
  }

  private ensureCanConfirm(): void {
    // 불변식: DRAFT 상태에서만 확정 가능
    if (this._status !== OrderStatus.DRAFT) {
      throw new InvalidStateTransitionError(
        `Cannot confirm order in ${this._status} status`
      );
    }
    
    // 불변식: 최소 1개 항목 필요
    if (this._items.length === 0) {
      throw new EmptyOrderError();
    }
    
    // 불변식: 최소 주문 금액
    if (this._totalAmount.isLessThan(Order.MINIMUM_ORDER_AMOUNT)) {
      throw new MinimumOrderAmountError(Order.MINIMUM_ORDER_AMOUNT);
    }
  }
}

┌─────────────────────────────────────────────────────────────────┐
│                    Order Aggregate (너무 큼!)                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Order (Root)                                                   │
│     │                                                            │
│     ├── OrderLineItem[]     ← 주문 항목                         │
│     ├── Payment             ← 결제 정보 (별도 생명주기)         │
│     ├── Shipment            ← 배송 정보 (별도 생명주기)         │
│     ├── Review[]            ← 리뷰 (별도 생명주기)              │
│     └── Customer            ← 고객 (완전히 다른 Aggregate!)     │
│                                                                  │
│   문제점:                                                        │
│   • 결제 상태 변경 시 전체 Order 락                             │
│   • 배송 추적 업데이트마다 Order 버전 충돌                      │
│   • 리뷰 작성이 주문과 충돌                                     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
│  Order Aggregate │  │ Payment Aggregate│  │Shipment Aggregate│
├──────────────────┤  ├──────────────────┤  ├──────────────────┤
│                  │  │                  │  │                  │
│  Order (Root)    │  │  Payment (Root)  │  │  Shipment (Root) │
│    │             │  │    │             │  │    │             │
│    └─ LineItem[] │  │    └─ orderId    │  │    └─ orderId    │
│    └─ customerId │  │    └─ amount     │  │    └─ tracking   │
│    └─ status     │  │    └─ status     │  │    └─ status     │
│                  │  │                  │  │                  │
└──────────────────┘  └──────────────────┘  └──────────────────┘
         │                    │                    │
         │    Domain Events   │                    │
         └────────────────────┴────────────────────┘
         
         OrderConfirmed → Payment 생성
         PaymentCompleted → Shipment 생성
         ShipmentDelivered → Order 완료 처리

┌──────────────────┐  ┌──────────────────┐
│ Customer Aggregate│ │  Review Aggregate │
├──────────────────┤  ├──────────────────┤
│                  │  │                  │
│  Customer (Root) │  │  Review (Root)   │
│    │             │  │    │             │
│    └─ profile    │  │    └─ orderId    │
│    └─ addresses  │  │    └─ productId  │
│                  │  │    └─ rating     │
└──────────────────┘  └──────────────────┘

// 도메인 레이어에 정의
interface OrderRepository {
  // 기본 CRUD
  findById(id: OrderId): Promise<Order | null>;
  save(order: Order): Promise<void>;
  delete(order: Order): Promise<void>;
  
  // 도메인 특화 쿼리
  findByCustomerId(customerId: CustomerId): Promise<Order[]>;
  findPendingOrders(): Promise<Order[]>;
  findByStatus(status: OrderStatus): Promise<Order[]>;
  
  // 존재 확인
  exists(id: OrderId): Promise<boolean>;
  
  // 페이징 (선택적)
  findAll(page: number, size: number): Promise<Page<Order>>;
}

// 인프라 레이어에 구현
class TypeORMOrderRepository implements OrderRepository {
  constructor(
    private readonly dataSource: DataSource,
    private readonly mapper: OrderMapper
  ) {}

  async findById(id: OrderId): Promise<Order | null> {
    const entity = await this.dataSource
      .getRepository(OrderEntity)
      .findOne({
        where: { id: id.value },
        relations: ['lineItems']  // Aggregate 전체 로드
      });
    
    return entity ? this.mapper.toDomain(entity) : null;
  }

  async save(order: Order): Promise<void> {
    const entity = this.mapper.toEntity(order);
    
    await this.dataSource.transaction(async manager => {
      // 기존 항목 삭제 후 새로 저장 (orphan removal)
      await manager
        .getRepository(OrderLineItemEntity)
        .delete({ orderId: order.id.value });
      
      // Aggregate 전체 저장
      await manager.getRepository(OrderEntity).save(entity);
    });
  }

  async findByCustomerId(customerId: CustomerId): Promise<Order[]> {
    const entities = await this.dataSource
      .getRepository(OrderEntity)
      .find({
        where: { customerId: customerId.value },
        relations: ['lineItems'],
        order: { createdAt: 'DESC' }
      });
    
    return entities.map(e => this.mapper.toDomain(e));
  }
}

// Mapper: 도메인 ↔ 영속성 변환
class OrderMapper {
  toDomain(entity: OrderEntity): Order {
    return Order.reconstitute({
      id: OrderId.from(entity.id),
      customerId: CustomerId.from(entity.customerId),
      status: OrderStatus.from(entity.status),
      items: entity.lineItems.map(item => 
        OrderLineItem.create(
          item.lineNumber,
          ProductId.from(item.productId),
          item.productName,
          Quantity.of(item.quantity),
          Money.of(item.unitPrice, Currency.from(item.currency))
        )
      ),
      shippingAddress: Address.create({
        street: entity.shippingStreet,
        city: entity.shippingCity,
        zipCode: entity.shippingZipCode,
        country: entity.shippingCountry
      }),
      totalAmount: Money.of(entity.totalAmount, Currency.from(entity.currency)),
      version: entity.version
    });
  }

  toEntity(order: Order): OrderEntity {
    const entity = new OrderEntity();
    entity.id = order.id.value;
    entity.customerId = order.customerId.value;
    entity.status = order.status.value;
    entity.totalAmount = order.totalAmount.amount;
    entity.currency = order.totalAmount.currency.code;
    entity.shippingStreet = order.shippingAddress.street;
    entity.shippingCity = order.shippingAddress.city;
    entity.shippingZipCode = order.shippingAddress.zipCode;
    entity.shippingCountry = order.shippingAddress.country;
    entity.version = order.version;
    
    entity.lineItems = order.items.map(item => {
      const lineEntity = new OrderLineItemEntity();
      lineEntity.orderId = order.id.value;
      lineEntity.lineNumber = item.lineNumber;
      lineEntity.productId = item.productId.value;
      lineEntity.productName = item.productName;
      lineEntity.quantity = item.quantity.value;
      lineEntity.unitPrice = item.unitPrice.amount;
      lineEntity.currency = item.unitPrice.currency.code;
      return lineEntity;
    });
    
    return entity;
  }
}

class Reservation extends AggregateRoot<ReservationId> {
  private _roomId: RoomId;
  private _guestId: GuestId;
  private _dateRange: DateRange;
  private _totalAmount: Money;
  private _status: ReservationStatus;
  private _specialRequests: string[];

  private constructor(id: ReservationId) {
    super(id);
  }

  static create(
    roomId: RoomId,
    guestId: GuestId,
    dateRange: DateRange,
    pricePerNight: Money
  ): Reservation {
    const reservation = new Reservation(ReservationId.generate());
    reservation._roomId = roomId;
    reservation._guestId = guestId;
    reservation._dateRange = dateRange;
    reservation._totalAmount = pricePerNight.multiply(dateRange.nights);
    reservation._status = ReservationStatus.PENDING;
    reservation._specialRequests = [];
    
    reservation.addDomainEvent(new ReservationCreatedEvent(
      reservation.id,
      roomId,
      guestId,
      dateRange
    ));
    
    return reservation;
  }

  confirm(paymentId: PaymentId): void {
    if (this._status !== ReservationStatus.PENDING) {
      throw new InvalidReservationStateError('Only pending reservations can be confirmed');
    }
    
    this._status = ReservationStatus.CONFIRMED;
    
    this.addDomainEvent(new ReservationConfirmedEvent(
      this.id,
      this._roomId,
      this._dateRange,
      paymentId
    ));
  }

  cancel(reason: CancellationReason): void {
    if (!this._status.canBeCancelled()) {
      throw new ReservationCannotBeCancelledError(this._status);
    }
    
    const isFreeCancellation = this.isWithinFreeCancellationPeriod();
    this._status = ReservationStatus.CANCELLED;
    
    this.addDomainEvent(new ReservationCancelledEvent(
      this.id,
      this._roomId,
      this._dateRange,
      reason,
      isFreeCancellation
    ));
  }

  checkIn(): void {
    if (this._status !== ReservationStatus.CONFIRMED) {
      throw new InvalidReservationStateError('Only confirmed reservations can check in');
    }
    
    if (!this._dateRange.isCheckInDate(new Date())) {
      throw new EarlyCheckInError(this._dateRange.startDate);
    }
    
    this._status = ReservationStatus.CHECKED_IN;
    
    this.addDomainEvent(new GuestCheckedInEvent(this.id, this._roomId));
  }

  checkOut(): void {
    if (this._status !== ReservationStatus.CHECKED_IN) {
      throw new InvalidReservationStateError('Only checked-in reservations can check out');
    }
    
    this._status = ReservationStatus.CHECKED_OUT;
    
    this.addDomainEvent(new GuestCheckedOutEvent(
      this.id,
      this._roomId,
      this._guestId
    ));
  }

  private isWithinFreeCancellationPeriod(): boolean {
    const hoursUntilCheckIn = this._dateRange.hoursUntilStart();
    return hoursUntilCheckIn >= 24;
  }

  // Getters
  get roomId(): RoomId { return this._roomId; }
  get guestId(): GuestId { return this._guestId; }
  get dateRange(): DateRange { return this._dateRange; }
  get totalAmount(): Money { return this._totalAmount; }
  get status(): ReservationStatus { return this._status; }
}