DDD 전술 설계 (Tactical Design)

flowchart LR
    AS[Application Service] -->|조회/저장| R[Repository]
    AS -->|행동 호출| AR
    AS -->|생성| F[Factory]
    F -->|만든다| AR
    R -->|저장/복원| AR

    subgraph AG[Aggregate]
        AR[Aggregate Root<br/>Entity] --> E[Entity]
        AR --> VO1[Value Object]
        E --> VO2[Value Object]
    end

    AS -->|여러 Aggregate에 걸친 규칙| DS[Domain Service]
    AR -.->|발생| DE[Domain Event]

주문 #1001 (상태: 결제 대기, 금액: 30,000원)
        │  결제 완료
        ▼
주문 #1001 (상태: 결제 완료, 금액: 30,000원)
        │  상품 하나 부분 취소
        ▼
주문 #1001 (상태: 부분 취소, 금액: 20,000원)

→ 속성은 계속 바뀌었지만 같은 "주문 #1001"이다

// ordering/domain/order-id.ts
export class OrderId {
  private constructor(readonly value: string) {}

  static generate(): OrderId {
    return new OrderId(randomUUID());
  }

  static of(value: string): OrderId {
    return new OrderId(value);
  }

  equals(other: OrderId): boolean {
    return this.value === other.value;
  }
}

// ordering/domain/order.ts
export class Order {
  private constructor(
    readonly id: OrderId,
    readonly customerId: CustomerId,
    private status: OrderStatus,
    private readonly lines: OrderLine[],
  ) {}

  // 상태 변경은 업무 용어로 된 메서드로만 한다
  pay(): void {
    if (this.status !== OrderStatus.PENDING) {
      throw new InvalidOrderStateException(this.id, this.status, 'pay');
    }
    this.status = OrderStatus.PAID;
  }

  cancel(): void {
    if (this.status === OrderStatus.SHIPPED || this.status === OrderStatus.DELIVERED) {
      throw new CannotCancelShippedOrderException(this.id);
    }
    this.status = OrderStatus.CANCELLED;
  }

  equals(other: Order): boolean {
    return this.id.equals(other.id);
  }
}

// 원시 타입만 쓴 코드
class Order {
  totalAmount: number;   // 원? 달러? 음수도 되나?
  currency: string;      // 'KRW', 'krw', '원' 다 들어갈 수 있다
  shippingZip: string;   // 형식 검증은 어디서?
}

// 금액 계산이 곳곳에 흩어진다
const total = order.totalAmount + shippingFee;   // 통화가 다르면?

// ordering/domain/discount-policy.service.ts
// 순수 도메인 로직: 프레임워크 의존 없음, 상태 없음
export class DiscountPolicy {
  calculate(order: Order, customer: Customer, coupon: Coupon | null): Money {
    const total = order.totalAmount();

    const gradeDiscount = customer.isVip() ? total.percent(10) : Money.zero();

    const couponDiscount = coupon?.isApplicableTo(order)
      ? coupon.discountFor(total)
      : Money.zero();

    // 중복 적용 불가: 더 큰 할인 하나만
    return gradeDiscount.isGreaterThanOrEqual(couponDiscount)
      ? gradeDiscount
      : couponDiscount;
  }
}

도메인이 보는 것:   orders.save(order) / orders.findById(id)
실제로 일어나는 일:  INSERT INTO orders ... / SELECT ... JOIN order_lines ...

// ordering/domain/order.repository.ts
export const ORDER_REPOSITORY = Symbol('ORDER_REPOSITORY');

export interface OrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  save(order: Order): Promise<void>;
}

// ordering/infrastructure/typeorm-order.repository.ts
@Injectable()
export class TypeOrmOrderRepository implements OrderRepository {
  constructor(
    @InjectRepository(OrderOrmEntity)
    private readonly repo: Repository<OrderOrmEntity>,
  ) {}

  async findById(id: OrderId): Promise<Order | null> {
    const row = await this.repo.findOne({
      where: { id: id.value },
      relations: { lines: true },
    });
    return row ? OrderMapper.toDomain(row) : null;
  }

  async save(order: Order): Promise<void> {
    await this.repo.save(OrderMapper.toOrm(order));
  }
}

// ordering/ordering.module.ts
@Module({
  providers: [
    { provide: ORDER_REPOSITORY, useClass: TypeOrmOrderRepository },
  ],
})
export class OrderingModule {}

// ordering/infrastructure/order.orm-entity.ts
@Entity('orders')
export class OrderOrmEntity {
  @PrimaryColumn('uuid') id: string;
  @Column() customerId: string;
  @Column() status: string;
  @OneToMany(() => OrderLineOrmEntity, (l) => l.order, { cascade: true })
  lines: OrderLineOrmEntity[];
}

// ordering/infrastructure/order.mapper.ts
export class OrderMapper {
  static toDomain(row: OrderOrmEntity): Order {
    return Order.reconstitute({
      id: OrderId.of(row.id),
      customerId: CustomerId.of(row.customerId),
      status: row.status as OrderStatus,
      lines: row.lines.map((l) =>
        OrderLine.reconstitute(l.productId, Money.of(l.unitPrice), Quantity.of(l.quantity)),
      ),
    });
  }

  static toOrm(order: Order): OrderOrmEntity {
    const snapshot = order.toSnapshot();
    const row = new OrderOrmEntity();
    row.id = snapshot.id;
    row.customerId = snapshot.customerId;
    row.status = snapshot.status;
    row.lines = snapshot.lines.map((l) => Object.assign(new OrderLineOrmEntity(), l));
    return row;
  }
}

export class Order extends AggregateRoot {
  private constructor(/* ... */) {
    super();
  }

  // 새 주문을 만들 때: 생성 규칙을 검사하고 이벤트를 기록한다
  static place(customerId: CustomerId, lines: OrderLineInput[]): Order {
    if (lines.length === 0) {
      throw new EmptyOrderException();
    }
    if (lines.length > 50) {
      throw new TooManyOrderLinesException(lines.length);
    }

    const order = new Order(
      OrderId.generate(),
      customerId,
      OrderStatus.PENDING,
      lines.map((l) => OrderLine.create(l.productId, l.unitPrice, l.quantity)),
    );
    order.record(new OrderPlaced(order.id, customerId, order.totalAmount()));
    return order;
  }

  // DB에서 복원할 때: 생성 규칙과 이벤트 없이 그대로 조립한다
  static reconstitute(props: OrderProps): Order {
    return new Order(props.id, props.customerId, props.status, props.lines);
  }
}

// 장바구니로부터 주문을 만든다: Cart와 상품 가격 정보가 필요하다
export class OrderFactory {
  createFromCart(cart: Cart, prices: PriceList): Order {
    const lines = cart.items.map((item) => ({
      productId: item.productId,
      unitPrice: prices.priceOf(item.productId), // 주문 시점 가격을 고정
      quantity: item.quantity,
    }));
    return Order.place(cart.customerId, lines);
  }
}

// (X) 주문 유스케이스가 모든 후속 작업을 직접 호출한다
async placeOrder(command) {
  const order = Order.place(...);
  await this.orders.save(order);
  await this.inventoryService.decrease(order.lines);   // 재고
  await this.pointService.accrue(order.customerId);    // 포인트
  await this.notificationService.send(order);          // 알림
}

ordering/
├── domain/
│   ├── order.ts                     # Aggregate Root (Entity)
│   ├── order-line.ts                # Entity (Aggregate 내부)
│   ├── order-id.ts                  # Value Object (ID)
│   ├── money.ts                     # Value Object
│   ├── quantity.ts                  # Value Object
│   ├── order.repository.ts          # Repository 인터페이스
│   ├── order.factory.ts             # Factory
│   ├── discount-policy.service.ts   # Domain Service
│   └── events/order-placed.event.ts # Domain Event
├── application/
│   └── place-order.service.ts       # Application Service
└── infrastructure/
    ├── typeorm-order.repository.ts  # Repository 구현
    ├── order.orm-entity.ts          # ORM 엔티티
    └── order.mapper.ts              # 도메인 ↔ ORM 변환