DDD 이론 8: Repository, Factory, Module

// 인프라 레이어: TypeORM Repository 구현
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', 'payments']
      });
    
    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.delete(OrderLineItemEntity, { orderId: order.id.value });
      
      // Aggregate 전체 저장
      await manager.save(OrderEntity, entity);
    });
  }

  async delete(order: Order): Promise<void> {
    await this.dataSource
      .getRepository(OrderEntity)
      .delete({ id: order.id.value });
  }

  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));
  }

  async findByStatus(status: OrderStatus): Promise<Order[]> {
    const entities = await this.dataSource
      .getRepository(OrderEntity)
      .find({
        where: { status: status.value },
        relations: ['lineItems']
      });
    
    return entities.map(e => this.mapper.toDomain(e));
  }

  async exists(id: OrderId): Promise<boolean> {
    const count = await this.dataSource
      .getRepository(OrderEntity)
      .count({ where: { id: id.value } });
    return count > 0;
  }
}

// 도메인 ↔ 영속성 변환
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
      }),
      totalAmount: Money.of(entity.totalAmount, Currency.KRW),
      createdAt: entity.createdAt,
      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.shippingStreet = order.shippingAddress.street;
    entity.shippingCity = order.shippingAddress.city;
    entity.shippingZipCode = order.shippingAddress.zipCode;
    entity.createdAt = order.createdAt;
    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;
  }
}

// 테스트용 In-Memory 구현
class InMemoryOrderRepository implements OrderRepository {
  private orders: Map<string, Order> = new Map();

  async findById(id: OrderId): Promise<Order | null> {
    return this.orders.get(id.value) ?? null;
  }

  async save(order: Order): Promise<void> {
    // 깊은 복사로 저장 (불변성 보장)
    this.orders.set(order.id.value, this.clone(order));
  }

  async delete(order: Order): Promise<void> {
    this.orders.delete(order.id.value);
  }

  async findByCustomerId(customerId: CustomerId): Promise<Order[]> {
    return Array.from(this.orders.values())
      .filter(order => order.customerId.equals(customerId));
  }

  async findByStatus(status: OrderStatus): Promise<Order[]> {
    return Array.from(this.orders.values())
      .filter(order => order.status === status);
  }

  async exists(id: OrderId): Promise<boolean> {
    return this.orders.has(id.value);
  }

  // 테스트 헬퍼
  clear(): void {
    this.orders.clear();
  }

  count(): number {
    return this.orders.size;
  }

  private clone(order: Order): Order {
    // 직렬화/역직렬화로 깊은 복사
    return Order.reconstitute(JSON.parse(JSON.stringify(order)));
  }
}

// 테스트에서 사용
describe('OrderService', () => {
  let orderRepository: InMemoryOrderRepository;
  let orderService: OrderService;

  beforeEach(() => {
    orderRepository = new InMemoryOrderRepository();
    orderService = new OrderService(orderRepository);
  });

  it('should create order', async () => {
    const orderId = await orderService.createOrder({
      customerId: 'cust-1',
      items: [{ productId: 'prod-1', quantity: 2 }]
    });

    const order = await orderRepository.findById(OrderId.from(orderId));
    expect(order).not.toBeNull();
    expect(order?.items).toHaveLength(1);
  });
});

// 복잡한 쿼리 조건을 캡슐화
interface Specification<T> {
  isSatisfiedBy(candidate: T): boolean;
  toQuery(): QueryCondition;  // DB 쿼리로 변환
}

class OrderByStatusSpec implements Specification<Order> {
  constructor(private readonly status: OrderStatus) {}

  isSatisfiedBy(order: Order): boolean {
    return order.status === this.status;
  }

  toQuery(): QueryCondition {
    return { status: this.status.value };
  }
}

class OrderByDateRangeSpec implements Specification<Order> {
  constructor(
    private readonly startDate: Date,
    private readonly endDate: Date
  ) {}

  isSatisfiedBy(order: Order): boolean {
    return order.createdAt >= this.startDate && 
           order.createdAt <= this.endDate;
  }

  toQuery(): QueryCondition {
    return {
      createdAt: Between(this.startDate, this.endDate)
    };
  }
}

// 조합 가능한 Specification
class AndSpecification<T> implements Specification<T> {
  constructor(
    private readonly left: Specification<T>,
    private readonly right: Specification<T>
  ) {}

  isSatisfiedBy(candidate: T): boolean {
    return this.left.isSatisfiedBy(candidate) && 
           this.right.isSatisfiedBy(candidate);
  }

  toQuery(): QueryCondition {
    return {
      ...this.left.toQuery(),
      ...this.right.toQuery()
    };
  }
}

// Repository에서 사용
interface OrderRepository {
  findBySpec(spec: Specification<Order>): Promise<Order[]>;
}

// 사용 예시
const pendingOrdersThisMonth = new AndSpecification(
  new OrderByStatusSpec(OrderStatus.PENDING),
  new OrderByDateRangeSpec(startOfMonth, endOfMonth)
);

const orders = await orderRepository.findBySpec(pendingOrdersThisMonth);

┌─────────────────────────────────────────────────────────────────┐
│                     의존성 방향 규칙                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────┐                                           │
│   │  Presentation   │ ──────────────────────────────┐           │
│   │   (Controller)  │                               │           │
│   └────────┬────────┘                               │           │
│            │                                        │           │
│            ▼                                        │           │
│   ┌─────────────────┐                               │           │
│   │   Application   │ ──────────────────────────────┤           │
│   │   (Use Cases)   │                               │           │
│   └────────┬────────┘                               │           │
│            │                                        │           │
│            ▼                                        ▼           │
│   ┌─────────────────┐                    ┌─────────────────┐   │
│   │     Domain      │ ◄────────────────  │ Infrastructure  │   │
│   │ (Entities, VOs) │   의존성 역전      │  (Repositories) │   │
│   └─────────────────┘                    └─────────────────┘   │
│                                                                  │
│   규칙:                                                          │
│   • 상위 레이어 → 하위 레이어 의존 가능                         │
│   • Domain은 어떤 것에도 의존하지 않음                          │
│   • Infrastructure → Domain (인터페이스 구현)                   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘