Split View: DDD(도메인 주도 설계) 완전 가이드 2025: 전략적/전술적 패턴, Bounded Context, 이벤트 스토밍

// 나쁜 예: 기술 중심 네이밍
class DataProcessor {
  processRecord(data: Record<string, unknown>): void {
    // ...
  }
}

// 좋은 예: 유비쿼터스 언어 반영
class OrderFulfillmentService {
  fulfillOrder(order: Order): FulfillmentResult {
    // ...
  }
}

┌─────────────────┐  ┌─────────────────┐
│ Catalog Context  │  │ Inventory Context│
│                  │  │                  │
│  Product:        │  │  Product:        │
│  - name          │  │  - sku           │
│  - description   │  │  - quantity      │
│  - images        │  │  - warehouse     │
│  - category      │  │  - reorderLevel  │
└─────────────────┘  └─────────────────┘

┌─────────────────┐  ┌─────────────────┐
│ Pricing Context  │  │ Shipping Context │
│                  │  │                  │
│  Product:        │  │  Product:        │
│  - basePrice     │  │  - weight        │
│  - discount      │  │  - dimensions    │
│  - promotions    │  │  - restrictions  │
└─────────────────┘  └─────────────────┘

[주문 컨텍스트] ←→ [결제 컨텍스트]
         Partnership

[컨텍스트 A] ── Shared Kernel ── [컨텍스트 B]
                 (공유 모듈)

[주문 컨텍스트]  →  [배송 컨텍스트]
  (Upstream)          (Downstream)
   Supplier            Customer

[외부 결제 API]  →  [우리 결제 연동]
   (Upstream)         (Downstream)
                       Conformist

// Anti-Corruption Layer 예시
class ExternalPaymentACL {
  private externalClient: ExternalPaymentClient;

  async processPayment(domainPayment: Payment): Promise<PaymentResult> {
    // 우리 도메인 모델 → 외부 API 모델로 변환
    const externalRequest = {
      amt: domainPayment.amount.value,
      ccy: domainPayment.amount.currency.code,
      merchant_ref: domainPayment.orderId.toString(),
      card_tkn: domainPayment.paymentMethod.token,
    };

    const externalResponse = await this.externalClient.charge(externalRequest);

    // 외부 API 모델 → 우리 도메인 모델로 변환
    return new PaymentResult(
      externalResponse.status === 'OK'
        ? PaymentStatus.APPROVED
        : PaymentStatus.DECLINED,
      new TransactionId(externalResponse.txn_id)
    );
  }
}

               [다운스트림 A]
              ↗
[OHS API] ──→  [다운스트림 B]
              ↘
               [다운스트림 C]

// Published Language 예시: Protocol Buffers
syntax = "proto3";

message OrderPlacedEvent {
  string order_id = 1;
  string customer_id = 2;
  repeated OrderLineItem items = 3;
  Money total_amount = 4;
  google.protobuf.Timestamp placed_at = 5;
}

┌──────────────┐    Partnership     ┌──────────────┐
│   Identity   │←──────────────────→│   Customer   │
│   Context    │                    │   Context    │
└──────┬───────┘                    └──────┬───────┘
       │                                   │
       │ OHS/PL                           │ Customer-Supplier
       │                                   │
       ▼                                   ▼
┌──────────────┐  Customer-Supplier ┌──────────────┐
│   Catalog    │───────────────────→│    Order     │
│   Context    │                    │   Context    │
└──────────────┘                    └──────┬───────┘
                                           │
                          ┌────────────────┼────────────────┐
                          │                │                │
                          ▼                ▼                ▼
                   ┌────────────┐  ┌────────────┐  ┌────────────┐
                   │  Payment   │  │  Inventory │  │  Shipping  │
                   │  Context   │  │  Context   │  │  Context   │
                   └─────┬──────┘  └────────────┘  └────────────┘
                         │
                         │ ACL
                         ▼
                   ┌────────────┐
                   │  External  │
                   │ Payment GW │
                   └────────────┘

// Entity 예시: Order
class Order {
  private readonly id: OrderId;
  private status: OrderStatus;
  private items: OrderLineItem[];
  private readonly customerId: CustomerId;
  private readonly placedAt: Date;

  constructor(
    id: OrderId,
    customerId: CustomerId,
    items: OrderLineItem[]
  ) {
    if (items.length === 0) {
      throw new EmptyOrderError();
    }
    this.id = id;
    this.customerId = customerId;
    this.items = items;
    this.status = OrderStatus.PLACED;
    this.placedAt = new Date();
  }

  get totalAmount(): Money {
    return this.items.reduce(
      (sum, item) => sum.add(item.subtotal),
      Money.zero('KRW')
    );
  }

  confirm(): void {
    if (this.status !== OrderStatus.PLACED) {
      throw new InvalidOrderStateError(
        `Cannot confirm order in ${this.status} status`
      );
    }
    this.status = OrderStatus.CONFIRMED;
  }

  cancel(reason: CancellationReason): void {
    if (this.status === OrderStatus.SHIPPED) {
      throw new InvalidOrderStateError(
        'Cannot cancel shipped order'
      );
    }
    this.status = OrderStatus.CANCELLED;
  }

  // 식별자로 동등성 판단
  equals(other: Order): boolean {
    return this.id.equals(other.id);
  }
}

// Value Object 예시: Money
class Money {
  private constructor(
    readonly value: number,
    readonly currency: Currency
  ) {
    if (value < 0) {
      throw new NegativeMoneyError();
    }
  }

  static of(value: number, currency: string): Money {
    return new Money(value, Currency.of(currency));
  }

  static zero(currency: string): Money {
    return new Money(0, Currency.of(currency));
  }

  add(other: Money): Money {
    this.assertSameCurrency(other);
    return new Money(this.value + other.value, this.currency);
  }

  subtract(other: Money): Money {
    this.assertSameCurrency(other);
    const result = this.value - other.value;
    if (result < 0) {
      throw new InsufficientFundsError();
    }
    return new Money(result, this.currency);
  }

  multiply(factor: number): Money {
    return new Money(
      Math.round(this.value * factor),
      this.currency
    );
  }

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

  private assertSameCurrency(other: Money): void {
    if (!this.currency.equals(other.currency)) {
      throw new CurrencyMismatchError(
        this.currency,
        other.currency
      );
    }
  }

  toString(): string {
    return `${this.currency.symbol}${this.value.toLocaleString()}`;
  }
}

// Value Object 예시: Address
class Address {
  constructor(
    readonly street: string,
    readonly city: string,
    readonly state: string,
    readonly zipCode: string,
    readonly country: Country
  ) {
    this.validate();
  }

  private validate(): void {
    if (!this.street || !this.city || !this.zipCode) {
      throw new InvalidAddressError();
    }
  }

  equals(other: Address): boolean {
    return (
      this.street === other.street &&
      this.city === other.city &&
      this.state === other.state &&
      this.zipCode === other.zipCode &&
      this.country.equals(other.country)
    );
  }

  withStreet(newStreet: string): Address {
    return new Address(
      newStreet,
      this.city,
      this.state,
      this.zipCode,
      this.country
    );
  }
}

// Aggregate Root: Order
class Order {
  private readonly id: OrderId;
  private items: OrderLineItem[];  // Aggregate 내부 엔티티
  private shippingAddress: Address; // Aggregate 내부 값 객체
  private status: OrderStatus;
  private readonly domainEvents: DomainEvent[] = [];

  // 외부에서 OrderLineItem에 직접 접근 불가
  // Aggregate Root의 메서드를 통해서만 조작
  addItem(
    productId: ProductId,
    productName: string,
    price: Money,
    quantity: Quantity
  ): void {
    if (this.status !== OrderStatus.DRAFT) {
      throw new InvalidOrderStateError(
        'Can only add items to draft orders'
      );
    }

    const existingItem = this.items.find(
      item => item.productId.equals(productId)
    );

    if (existingItem) {
      existingItem.increaseQuantity(quantity);
    } else {
      this.items.push(
        new OrderLineItem(productId, productName, price, quantity)
      );
    }

    this.domainEvents.push(
      new OrderItemAdded(this.id, productId, quantity)
    );
  }

  removeItem(productId: ProductId): void {
    if (this.status !== OrderStatus.DRAFT) {
      throw new InvalidOrderStateError(
        'Can only remove items from draft orders'
      );
    }
    this.items = this.items.filter(
      item => !item.productId.equals(productId)
    );
  }

  place(): void {
    if (this.items.length === 0) {
      throw new EmptyOrderError();
    }
    if (this.status !== OrderStatus.DRAFT) {
      throw new InvalidOrderStateError(
        'Can only place draft orders'
      );
    }
    this.status = OrderStatus.PLACED;
    this.domainEvents.push(
      new OrderPlaced(this.id, this.customerId, this.totalAmount)
    );
  }

  pullDomainEvents(): DomainEvent[] {
    const events = [...this.domainEvents];
    this.domainEvents.length = 0;
    return events;
  }
}

좋은 Aggregate 설계:                나쁜 Aggregate 설계:

┌───────────────────┐              ┌──────────────────────────┐
│ Order (Root)      │              │ Order (Root)             │
│  ├─ LineItem      │              │  ├─ LineItem             │
│  ├─ LineItem      │              │  ├─ LineItem             │
│  └─ ShippingAddr  │              │  ├─ Customer (Entity!)   │
└───────────────────┘              │  ├─ Product (Entity!)    │
                                   │  ├─ PaymentInfo          │
작고 집중된 Aggregate                │  └─ ShippingHistory     │
                                   └──────────────────────────┘
                                   너무 큰 God Aggregate

// Repository 인터페이스 (도메인 레이어)
interface OrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  findByCustomer(customerId: CustomerId): Promise<Order[]>;
  save(order: Order): Promise<void>;
  delete(order: Order): Promise<void>;
  nextId(): OrderId;
}

// Repository 구현 (인프라 레이어)
class PostgresOrderRepository implements OrderRepository {
  constructor(private readonly pool: Pool) {}

  async findById(id: OrderId): Promise<Order | null> {
    const result = await this.pool.query(
      `SELECT o.*, json_agg(oi.*) as items
       FROM orders o
       LEFT JOIN order_items oi ON o.id = oi.order_id
       WHERE o.id = $1
       GROUP BY o.id`,
      [id.value]
    );

    if (result.rows.length === 0) return null;
    return this.toDomain(result.rows[0]);
  }

  async save(order: Order): Promise<void> {
    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');

      await client.query(
        `INSERT INTO orders (id, customer_id, status, placed_at)
         VALUES ($1, $2, $3, $4)
         ON CONFLICT (id) DO UPDATE SET status = $3`,
        [order.id.value, order.customerId.value,
         order.status, order.placedAt]
      );

      // Aggregate 내부 엔티티도 함께 저장
      await client.query(
        'DELETE FROM order_items WHERE order_id = $1',
        [order.id.value]
      );

      for (const item of order.items) {
        await client.query(
          `INSERT INTO order_items
           (order_id, product_id, name, price, quantity)
           VALUES ($1, $2, $3, $4, $5)`,
          [order.id.value, item.productId.value,
           item.name, item.price.value, item.quantity.value]
        );
      }

      await client.query('COMMIT');
    } catch (e) {
      await client.query('ROLLBACK');
      throw e;
    } finally {
      client.release();
    }
  }

  nextId(): OrderId {
    return OrderId.generate();
  }

  private toDomain(row: any): Order {
    // DB 행 → 도메인 객체 변환
    return Order.reconstitute(
      new OrderId(row.id),
      new CustomerId(row.customer_id),
      OrderStatus.from(row.status),
      row.items.map((i: any) => OrderLineItem.reconstitute(
        new ProductId(i.product_id),
        i.name,
        Money.of(i.price, 'KRW'),
        new Quantity(i.quantity)
      )),
      new Date(row.placed_at)
    );
  }
}

// Domain Service: 주문 가격 계산
class OrderPricingService {
  calculateTotal(
    items: OrderLineItem[],
    discountPolicy: DiscountPolicy,
    customer: CustomerGrade
  ): Money {
    const subtotal = items.reduce(
      (sum, item) => sum.add(item.subtotal),
      Money.zero('KRW')
    );

    const discount = discountPolicy.calculateDiscount(
      subtotal,
      customer
    );

    return subtotal.subtract(discount);
  }
}

// Domain Service vs Application Service 구분
// Domain Service: 순수한 도메인 로직
class TransferService {
  transfer(
    source: Account,
    target: Account,
    amount: Money
  ): void {
    source.withdraw(amount);
    target.deposit(amount);
  }
}

// Application Service: 유스케이스 조율 (인프라 의존)
class TransferApplicationService {
  constructor(
    private accountRepo: AccountRepository,
    private transferService: TransferService,
    private eventBus: EventBus
  ) {}

  async execute(command: TransferCommand): Promise<void> {
    const source = await this.accountRepo.findById(
      command.sourceAccountId
    );
    const target = await this.accountRepo.findById(
      command.targetAccountId
    );

    this.transferService.transfer(
      source, target, command.amount
    );

    await this.accountRepo.save(source);
    await this.accountRepo.save(target);

    await this.eventBus.publish(
      new MoneyTransferred(
        command.sourceAccountId,
        command.targetAccountId,
        command.amount
      )
    );
  }
}

// Domain Event 정의
abstract class DomainEvent {
  readonly occurredAt: Date;
  readonly eventId: string;

  constructor() {
    this.occurredAt = new Date();
    this.eventId = crypto.randomUUID();
  }

  abstract get eventType(): string;
}

class OrderPlaced extends DomainEvent {
  constructor(
    readonly orderId: OrderId,
    readonly customerId: CustomerId,
    readonly totalAmount: Money,
    readonly items: ReadonlyArray<OrderItemSnapshot>
  ) {
    super();
  }

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

class PaymentCompleted extends DomainEvent {
  constructor(
    readonly orderId: OrderId,
    readonly paymentId: PaymentId,
    readonly amount: Money
  ) {
    super();
  }

  get eventType(): string {
    return 'payment.completed';
  }
}

// Event Handler
class OrderPlacedHandler {
  constructor(
    private inventoryService: InventoryService,
    private notificationService: NotificationService
  ) {}

  async handle(event: OrderPlaced): Promise<void> {
    // 재고 예약
    await this.inventoryService.reserveStock(
      event.items.map(item => ({
        productId: item.productId,
        quantity: item.quantity,
      }))
    );

    // 주문 확인 알림 발송
    await this.notificationService.sendOrderConfirmation(
      event.customerId,
      event.orderId
    );
  }
}

class OrderFactory {
  constructor(
    private orderRepo: OrderRepository,
    private pricingService: OrderPricingService
  ) {}

  createOrder(
    customerId: CustomerId,
    items: CreateOrderItemDTO[],
    shippingAddress: Address,
    discountCode?: string
  ): Order {
    const orderId = this.orderRepo.nextId();

    const orderItems = items.map(item =>
      new OrderLineItem(
        new ProductId(item.productId),
        item.productName,
        Money.of(item.price, 'KRW'),
        new Quantity(item.quantity)
      )
    );

    const order = new Order(
      orderId,
      customerId,
      orderItems,
      shippingAddress
    );

    if (discountCode) {
      order.applyDiscountCode(new DiscountCode(discountCode));
    }

    return order;
  }
}

시간 흐름 →

[고객 등록됨]  [상품 검색됨]  [장바구니에 담김]  [주문 생성됨]
                                                    |
                                               [결제 요청됨]
                                                    |
                                      [결제 승인됨]  OR  [결제 실패됨]
                                           |
                                      [주문 확정됨]
                                           |
                                      [배송 시작됨]
                                           |
                                      [배송 완료됨]

[고객]     →  [주문하기]     →  [Order Aggregate]  →  [주문 생성됨]
(Actor)       (Command)         (Aggregate)           (Event)
                                                         |
                                                    [결제 정책]
                                                      (Policy)
                                                         |
                                                    [결제 요청하기]
                                                     (Command)

from __future__ import annotations
from dataclasses import dataclass, field
from typing import Optional
from uuid import uuid4
from datetime import datetime
from enum import Enum


# Value Object
@dataclass(frozen=True)
class Money:
    amount: int
    currency: str = "KRW"

    def __post_init__(self) -> None:
        if self.amount < 0:
            raise ValueError("Money amount cannot be negative")

    def add(self, other: Money) -> Money:
        self._assert_same_currency(other)
        return Money(self.amount + other.amount, self.currency)

    def subtract(self, other: Money) -> Money:
        self._assert_same_currency(other)
        if self.amount - other.amount < 0:
            raise ValueError("Insufficient funds")
        return Money(self.amount - other.amount, self.currency)

    def _assert_same_currency(self, other: Money) -> None:
        if self.currency != other.currency:
            raise ValueError(
                f"Currency mismatch: {self.currency} vs {other.currency}"
            )


@dataclass(frozen=True)
class OrderId:
    value: str

    @staticmethod
    def generate() -> OrderId:
        return OrderId(str(uuid4()))


@dataclass(frozen=True)
class CustomerId:
    value: str


# Entity
class OrderStatus(Enum):
    DRAFT = "DRAFT"
    PLACED = "PLACED"
    CONFIRMED = "CONFIRMED"
    SHIPPED = "SHIPPED"
    DELIVERED = "DELIVERED"
    CANCELLED = "CANCELLED"


@dataclass
class OrderLineItem:
    product_id: str
    product_name: str
    price: Money
    quantity: int

    @property
    def subtotal(self) -> Money:
        return Money(
            self.price.amount * self.quantity,
            self.price.currency
        )


# Domain Event
@dataclass(frozen=True)
class DomainEvent:
    event_id: str = field(default_factory=lambda: str(uuid4()))
    occurred_at: datetime = field(default_factory=datetime.utcnow)


@dataclass(frozen=True)
class OrderPlacedEvent(DomainEvent):
    order_id: str = ""
    customer_id: str = ""
    total_amount: int = 0


# Aggregate Root
class Order:
    def __init__(
        self,
        order_id: OrderId,
        customer_id: CustomerId,
    ) -> None:
        self._id = order_id
        self._customer_id = customer_id
        self._items: list[OrderLineItem] = []
        self._status = OrderStatus.DRAFT
        self._events: list[DomainEvent] = []
        self._created_at = datetime.utcnow()

    @property
    def id(self) -> OrderId:
        return self._id

    @property
    def status(self) -> OrderStatus:
        return self._status

    @property
    def total_amount(self) -> Money:
        if not self._items:
            return Money(0)
        total = Money(0)
        for item in self._items:
            total = total.add(item.subtotal)
        return total

    def add_item(
        self,
        product_id: str,
        product_name: str,
        price: Money,
        quantity: int,
    ) -> None:
        if self._status != OrderStatus.DRAFT:
            raise ValueError("Can only add items to draft orders")
        if quantity <= 0:
            raise ValueError("Quantity must be positive")

        self._items.append(
            OrderLineItem(product_id, product_name, price, quantity)
        )

    def place(self) -> None:
        if not self._items:
            raise ValueError("Cannot place an empty order")
        if self._status != OrderStatus.DRAFT:
            raise ValueError("Can only place draft orders")

        self._status = OrderStatus.PLACED
        self._events.append(
            OrderPlacedEvent(
                order_id=self._id.value,
                customer_id=self._customer_id.value,
                total_amount=self.total_amount.amount,
            )
        )

    def confirm(self) -> None:
        if self._status != OrderStatus.PLACED:
            raise ValueError("Can only confirm placed orders")
        self._status = OrderStatus.CONFIRMED

    def cancel(self) -> None:
        if self._status in (OrderStatus.SHIPPED, OrderStatus.DELIVERED):
            raise ValueError("Cannot cancel shipped or delivered orders")
        self._status = OrderStatus.CANCELLED

    def collect_events(self) -> list[DomainEvent]:
        events = list(self._events)
        self._events.clear()
        return events


# Repository Interface
from abc import ABC, abstractmethod


class OrderRepository(ABC):
    @abstractmethod
    async def find_by_id(self, order_id: OrderId) -> Optional[Order]:
        ...

    @abstractmethod
    async def save(self, order: Order) -> None:
        ...

    @abstractmethod
    def next_id(self) -> OrderId:
        ...


# Application Service (Use Case)
class PlaceOrderUseCase:
    def __init__(
        self,
        order_repo: OrderRepository,
        event_publisher: EventPublisher,
    ) -> None:
        self._order_repo = order_repo
        self._event_publisher = event_publisher

    async def execute(self, command: PlaceOrderCommand) -> str:
        order_id = self._order_repo.next_id()
        order = Order(order_id, CustomerId(command.customer_id))

        for item in command.items:
            order.add_item(
                product_id=item.product_id,
                product_name=item.product_name,
                price=Money(item.price),
                quantity=item.quantity,
            )

        order.place()
        await self._order_repo.save(order)

        for event in order.collect_events():
            await self._event_publisher.publish(event)

        return order_id.value

                    ┌──────────────┐
                    │   Client     │
                    └──────┬───────┘
                           │
              ┌────────────┴────────────┐
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │  Command     │          │   Query      │
       │  Handler     │          │   Handler    │
       └──────┬──────┘          └──────┬──────┘
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │  Write       │          │  Read        │
       │  Model       │  ─sync─→│  Model       │
       │  (DDD)       │          │  (DTO)       │
       └──────┬──────┘          └──────┬──────┘
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │  Write DB    │          │  Read DB     │
       │  (Postgres)  │          │  (Redis/ES)  │
       └─────────────┘          └─────────────┘

// Command Side
class PlaceOrderCommandHandler {
  constructor(
    private orderRepo: OrderRepository,
    private eventBus: EventBus
  ) {}

  async handle(command: PlaceOrderCommand): Promise<OrderId> {
    const order = OrderFactory.create(
      command.customerId,
      command.items,
      command.shippingAddress
    );

    order.place();
    await this.orderRepo.save(order);

    const events = order.pullDomainEvents();
    for (const event of events) {
      await this.eventBus.publish(event);
    }

    return order.id;
  }
}

// Query Side
class OrderQueryService {
  constructor(private readDb: ReadDatabase) {}

  async getOrderSummary(
    orderId: string
  ): Promise<OrderSummaryDTO> {
    return this.readDb.query(
      'SELECT * FROM order_summaries WHERE id = $1',
      [orderId]
    );
  }

  async getCustomerOrders(
    customerId: string,
    page: number,
    size: number
  ): Promise<PaginatedResult<OrderListDTO>> {
    return this.readDb.query(
      `SELECT * FROM order_summaries
       WHERE customer_id = $1
       ORDER BY placed_at DESC
       LIMIT $2 OFFSET $3`,
      [customerId, size, (page - 1) * size]
    );
  }
}

// Projection (이벤트 → Read Model 동기화)
class OrderSummaryProjection {
  constructor(private readDb: ReadDatabase) {}

  async on(event: OrderPlaced): Promise<void> {
    await this.readDb.execute(
      `INSERT INTO order_summaries
       (id, customer_id, total, status, placed_at)
       VALUES ($1, $2, $3, $4, $5)`,
      [event.orderId, event.customerId,
       event.totalAmount, 'PLACED', event.occurredAt]
    );
  }

  async on(event: OrderConfirmed): Promise<void> {
    await this.readDb.execute(
      `UPDATE order_summaries SET status = 'CONFIRMED'
       WHERE id = $1`,
      [event.orderId]
    );
  }
}

// Event-Sourced Aggregate
class EventSourcedOrder {
  private id: OrderId;
  private status: OrderStatus;
  private items: OrderLineItem[] = [];
  private version: number = 0;
  private uncommittedEvents: DomainEvent[] = [];

  // 이벤트로부터 상태 복원
  static fromHistory(events: DomainEvent[]): EventSourcedOrder {
    const order = new EventSourcedOrder();
    for (const event of events) {
      order.apply(event, false);
    }
    return order;
  }

  place(customerId: CustomerId, items: OrderLineItem[]): void {
    this.apply(
      new OrderPlaced(OrderId.generate(), customerId, items),
      true
    );
  }

  confirm(): void {
    if (this.status !== OrderStatus.PLACED) {
      throw new InvalidOrderStateError();
    }
    this.apply(new OrderConfirmed(this.id), true);
  }

  private apply(event: DomainEvent, isNew: boolean): void {
    this.when(event);
    this.version++;
    if (isNew) {
      this.uncommittedEvents.push(event);
    }
  }

  private when(event: DomainEvent): void {
    if (event instanceof OrderPlaced) {
      this.id = event.orderId;
      this.status = OrderStatus.PLACED;
      this.items = [...event.items];
    } else if (event instanceof OrderConfirmed) {
      this.status = OrderStatus.CONFIRMED;
    } else if (event instanceof OrderCancelled) {
      this.status = OrderStatus.CANCELLED;
    }
  }

  getUncommittedEvents(): DomainEvent[] {
    return [...this.uncommittedEvents];
  }

  clearUncommittedEvents(): void {
    this.uncommittedEvents = [];
  }
}

// Event Store
class EventStore {
  async save(
    aggregateId: string,
    events: DomainEvent[],
    expectedVersion: number
  ): Promise<void> {
    await this.db.query(
      `INSERT INTO event_store
       (aggregate_id, event_type, event_data, version, created_at)
       VALUES ($1, $2, $3, $4, $5)`,
      events.map((event, i) => [
        aggregateId,
        event.eventType,
        JSON.stringify(event),
        expectedVersion + i + 1,
        event.occurredAt,
      ])
    );
  }

  async load(aggregateId: string): Promise<DomainEvent[]> {
    const result = await this.db.query(
      `SELECT event_type, event_data
       FROM event_store
       WHERE aggregate_id = $1
       ORDER BY version ASC`,
      [aggregateId]
    );
    return result.rows.map(row =>
      this.deserialize(row.event_type, row.event_data)
    );
  }
}

┌─────────────────────────────────────────────────┐
│                 이커머스 시스템                     │
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │ Catalog  │  │  Order   │  │ Payment  │       │
│  │ Service  │  │ Service  │  │ Service  │       │
│  │          │  │          │  │          │       │
│  │ (Catalog │  │ (Order   │  │ (Payment │       │
│  │  BC)     │  │  BC)     │  │  BC)     │       │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
│       │              │              │             │
│       └──────────────┴──────────────┘             │
│                Event Bus                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │Inventory │  │ Shipping │  │Notific.  │       │
│  │ Service  │  │ Service  │  │ Service  │       │
│  └──────────┘  └──────────┘  └──────────┘       │
└─────────────────────────────────────────────────┘

// Order Service - 이벤트 발행
class OrderService {
  async placeOrder(command: PlaceOrderCommand): Promise<void> {
    const order = this.orderFactory.create(command);
    order.place();

    await this.orderRepo.save(order);

    // 이벤트 발행 (Outbox Pattern)
    await this.outbox.store(
      order.pullDomainEvents().map(event => ({
        aggregateId: order.id.value,
        eventType: event.eventType,
        payload: JSON.stringify(event),
      }))
    );
  }
}

// Inventory Service - 이벤트 구독
class InventoryEventHandler {
  @Subscribe('order.placed')
  async onOrderPlaced(event: OrderPlacedEvent): Promise<void> {
    for (const item of event.items) {
      await this.inventoryService.reserveStock(
        item.productId,
        item.quantity
      );
    }
  }

  @Subscribe('order.cancelled')
  async onOrderCancelled(
    event: OrderCancelledEvent
  ): Promise<void> {
    for (const item of event.items) {
      await this.inventoryService.releaseStock(
        item.productId,
        item.quantity
      );
    }
  }
}

// 안티 패턴: 빈혈 도메인 모델
class Order {
  id: string;
  status: string;
  items: OrderItem[];
  totalAmount: number;
  // getter/setter만 존재, 비즈니스 로직 없음
}

class OrderService {
  placeOrder(order: Order): void {
    // 모든 비즈니스 로직이 Service에!
    if (order.items.length === 0) {
      throw new Error('Empty order');
    }
    if (order.status !== 'DRAFT') {
      throw new Error('Invalid status');
    }
    order.status = 'PLACED';
    order.totalAmount = order.items.reduce(
      (sum, item) => sum + item.price * item.quantity, 0
    );
  }
}

// 해결: 풍부한 도메인 모델 (Rich Domain Model)
class Order {
  private status: OrderStatus;
  private items: OrderLineItem[];

  place(): void {
    this.assertNotEmpty();
    this.assertDraft();
    this.status = OrderStatus.PLACED;
  }

  get totalAmount(): Money {
    return this.items.reduce(
      (sum, item) => sum.add(item.subtotal),
      Money.zero('KRW')
    );
  }

  private assertNotEmpty(): void {
    if (this.items.length === 0) {
      throw new EmptyOrderError();
    }
  }

  private assertDraft(): void {
    if (this.status !== OrderStatus.DRAFT) {
      throw new InvalidOrderStateError(this.status);
    }
  }
}

// 안티 패턴: God Aggregate
class Customer {
  id: CustomerId;
  name: string;
  email: Email;
  orders: Order[];           // 모든 주문!
  addresses: Address[];      // 모든 주소!
  payments: PaymentMethod[]; // 모든 결제수단!
  reviews: Review[];         // 모든 리뷰!
  wishlist: Product[];       // 위시리스트!
  loyaltyPoints: number;
  // ...수백 개의 필드
}

// 해결: 작은 Aggregate로 분리
class Customer {
  id: CustomerId;
  name: CustomerName;
  email: Email;
  grade: CustomerGrade;
}

class CustomerAddressBook {
  customerId: CustomerId;
  addresses: Address[];
}

class CustomerWallet {
  customerId: CustomerId;
  paymentMethods: PaymentMethod[];
  loyaltyPoints: LoyaltyPoints;
}

Before: UserService.updateUserStatus(userId, "active")
After:  customer.activate()

// Before: 원시 타입 남용
function createOrder(
  price: number,
  currency: string,
  street: string,
  city: string,
  zip: string
): void { /* ... */ }

// After: Value Object 도입
function createOrder(
  amount: Money,
  address: Address
): void { /* ... */ }

// Before: Service에 있는 로직
class OrderService {
  canCancel(order: OrderDTO): boolean {
    return order.status !== 'SHIPPED'
      && order.status !== 'DELIVERED';
  }
}

// After: Entity에 있는 로직
class Order {
  canCancel(): boolean {
    return !this.isShipped() && !this.isDelivered();
  }
}

src/
├── modules/
│   ├── order/                    # Order Bounded Context
│   │   ├── domain/
│   │   │   ├── model/
│   │   │   │   ├── Order.ts            # Aggregate Root
│   │   │   │   ├── OrderLineItem.ts    # Entity
│   │   │   │   ├── OrderId.ts          # Value Object
│   │   │   │   ├── OrderStatus.ts      # Value Object (enum)
│   │   │   │   └── Money.ts            # Value Object
│   │   │   ├── event/
│   │   │   │   ├── OrderPlaced.ts
│   │   │   │   └── OrderConfirmed.ts
│   │   │   ├── service/
│   │   │   │   └── OrderPricingService.ts
│   │   │   ├── repository/
│   │   │   │   └── OrderRepository.ts  # Interface
│   │   │   └── factory/
│   │   │       └── OrderFactory.ts
│   │   ├── application/
│   │   │   ├── command/
│   │   │   │   ├── PlaceOrderCommand.ts
│   │   │   │   └── PlaceOrderHandler.ts
│   │   │   ├── query/
│   │   │   │   ├── GetOrderQuery.ts
│   │   │   │   └── GetOrderHandler.ts
│   │   │   └── event-handler/
│   │   │       └── OrderPlacedHandler.ts
│   │   └── infrastructure/
│   │       ├── persistence/
│   │       │   └── PostgresOrderRepository.ts
│   │       ├── messaging/
│   │       │   └── KafkaOrderEventPublisher.ts
│   │       └── api/
│   │           └── OrderController.ts
│   │
│   ├── payment/                  # Payment Bounded Context
│   │   ├── domain/
│   │   ├── application/
│   │   └── infrastructure/
│   │
│   └── shared/                   # Shared Kernel
│       ├── domain/
│       │   ├── DomainEvent.ts
│       │   ├── AggregateRoot.ts
│       │   └── ValueObject.ts
│       └── infrastructure/
│           ├── EventBus.ts
│           └── UnitOfWork.ts
│
└── main.ts

src/
├── order/                         # Order Bounded Context
│   ├── domain/
│   │   ├── __init__.py
│   │   ├── model/
│   │   │   ├── order.py           # Aggregate Root
│   │   │   ├── order_line_item.py # Entity
│   │   │   └── value_objects.py   # Money, OrderId, etc.
│   │   ├── events/
│   │   │   └── order_events.py
│   │   ├── services/
│   │   │   └── pricing_service.py
│   │   └── repositories/
│   │       └── order_repository.py  # ABC
│   ├── application/
│   │   ├── commands/
│   │   │   └── place_order.py
│   │   └── queries/
│   │       └── get_order.py
│   └── infrastructure/
│       ├── persistence/
│       │   └── sqlalchemy_order_repo.py
│       └── api/
│           └── order_routes.py
│
├── payment/                        # Payment Bounded Context
│   ├── domain/
│   ├── application/
│   └── infrastructure/
│
└── shared_kernel/
    ├── domain_event.py
    ├── aggregate_root.py
    └── value_object.py