DDD
전술적 설계

class User {
  private readonly id: UserId;
  private name: string;
  private email: Email;

  constructor(id: UserId, name: string, email: Email) {
    this.id = id;
    this.name = name;
    this.email = email;
  }

  // 이름이 바뀌어도 같은 User
  changeName(newName: string): void {
    this.name = newName;
  }

  // 동등성은 ID로 판단
  equals(other: User): boolean {
    return this.id.equals(other.id);
  }
}

class Money {
  private readonly amount: number;
  private readonly currency: Currency;

  private constructor(amount: number, currency: Currency) {
    this.amount = amount;
    this.currency = currency;
  }

  static create(amount: number, currency: Currency): Money {
    return new Money(amount, currency);
  }

  // 불변 - 새 객체 반환
  add(other: Money): Money {
    if (!this.currency.equals(other.currency)) {
      throw new Error('Currency mismatch');
    }
    return Money.create(this.amount + other.amount, this.currency);
  }

  // 동등성은 값으로 판단
  equals(other: Money): boolean {
    return this.amount === other.amount &&
           this.currency.equals(other.currency);
  }
}

// 도메인 레이어에 정의
interface OrderRepository {
  // Aggregate 단위로 조회
  findById(id: OrderId): Promise<Order | null>;
  findByCustomerId(customerId: CustomerId): Promise<Order[]>;

  // Aggregate 단위로 저장
  save(order: Order): Promise<void>;

  // Aggregate 단위로 삭제
  delete(order: Order): Promise<void>;

  // 다음 ID 생성 (옵션)
  nextId(): OrderId;
}

// 도메인 로직은 구현 세부사항을 모름
class ConfirmOrderUseCase {
  constructor(private orderRepo: OrderRepository) {}

  async execute(orderId: string): Promise<void> {
    const order = await this.orderRepo.findById(
      new OrderId(orderId)
    );
    if (!order) throw new Error('Order not found');

    order.confirm();
    await this.orderRepo.save(order);
  }
}

// 인프라 레이어에 구현
class PostgresOrderRepository implements OrderRepository {
  constructor(private db: Database) {}

  async findById(id: OrderId): Promise<Order | null> {
    const row = await this.db.query(
      'SELECT * FROM orders WHERE id = $1',
      [id.value]
    );
    if (!row) return null;

    // DB 모델 → 도메인 모델 변환
    return this.toDomain(row);
  }

  async save(order: Order): Promise<void> {
    // 도메인 모델 → DB 모델 변환
    const data = this.toPersistence(order);

    await this.db.query(
      `INSERT INTO orders (...) VALUES (...)
       ON CONFLICT (id) DO UPDATE SET ...`,
      [data]
    );

    // OrderLine도 함께 저장 (Aggregate 단위)
    await this.saveOrderLines(order);
  }

  private toDomain(row: any): Order { ... }
  private toPersistence(order: Order): any { ... }
}

// 불변의 이벤트 객체
class OrderConfirmedEvent implements DomainEvent {
  readonly occurredOn: Date;
  readonly orderId: string;
  readonly customerId: string;
  readonly totalAmount: number;

  constructor(order: Order) {
    this.occurredOn = new Date();
    this.orderId = order.id.value;
    this.customerId = order.customerId.value;
    this.totalAmount = order.totalAmount.value;
  }

  get eventType(): string {
    return 'order.confirmed';
  }
}

// Aggregate에서 이벤트 발행
class Order extends AggregateRoot {
  confirm(): void {
    // 비즈니스 규칙 검증
    if (this.lines.length === 0) {
      throw new Error('Cannot confirm empty order');
    }
    this.status = OrderStatus.Confirmed;

    // 도메인 이벤트 등록
    this.addDomainEvent(new OrderConfirmedEvent(this));
  }
}

// 이벤트 핸들러 (Application Layer)
class SendOrderConfirmationEmail
  implements DomainEventHandler<OrderConfirmedEvent> {

  constructor(
    private emailService: EmailService,
    private customerRepo: CustomerRepository
  ) {}

  async handle(event: OrderConfirmedEvent): Promise<void> {
    const customer = await this.customerRepo.findById(
      new CustomerId(event.customerId)
    );
    if (!customer) return;

    await this.emailService.send({
      to: customer.email,
      subject: '주문이 확정되었습니다',
      body: `주문번호: ${event.orderId}`
    });
  }
}

// 다른 Bounded Context로 이벤트 전파
class ReserveInventoryOnOrderConfirmed
  implements DomainEventHandler<OrderConfirmedEvent> {

  constructor(private inventoryService: InventoryService) {}

  async handle(event: OrderConfirmedEvent): Promise<void> {
    await this.inventoryService.reserve(event.orderId);
  }
}