Refactoring Legacy Toward DDD

# Find the most-changed files in the last 6 months — these are your hotspots
git log --since="6 months ago" --name-only --pretty=format: | \
  sort | uniq -c | sort -rn | head -20

# Context: Order Fulfillment
 
## Ubiquitous Language
- **Order**: a confirmed purchase request, immutable once placed
- **Allocation**: the reservation of stock for an order, reversible until dispatched
- **Pick List**: the warehouse instruction to gather items, generated from allocations
- **Dispatch**: the physical handover to the carrier, finalises the allocation
 
## What's NOT in this context
- Payment processing (→ Billing Context)
- Product pricing (→ Pricing Context)
- Customer profile (→ CRM Context)

// Legacy: primitives everywhere
public class OrderService {
    public void placeOrder(String customerId, String productCode, 
                           int quantity, BigDecimal price, String currency) {
        // Is customerId a UUID? A legacy number? An email?
        // Is price already tax-inclusive? Per-unit? Per-lot?
        // Nobody knows without reading 300 lines.
    }
}
 
// After: value objects make the intent explicit
public class OrderService {
    public void placeOrder(
        CustomerId customerId,
        ProductSku sku,
        Quantity quantity,
        Money unitPrice
    ) {
        // CustomerId knows its format and validates on construction
        // Quantity enforces positivity
        // Money carries currency and provides arithmetic
    }
}
 
// Value object: immutable, self-validating
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount);
        Objects.requireNonNull(currency);
        if (amount.scale() > 2) throw new IllegalArgumentException("Max 2 decimal places");
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) 
            throw new IllegalArgumentException("Currency mismatch");
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

// Legacy: invariants enforced in a service method (fragile, hard to find)
public class OrderService {
    public void addItem(Long orderId, Long productId, int qty) {
        Order order = orderRepo.findById(orderId);
        if (order.getStatus().equals("CONFIRMED")) {
            throw new RuntimeException("order already confirmed");
        }
        if (order.getItems().size() >= 50) {
            throw new RuntimeException("too many items");
        }
        // ... more rule checks scattered across other service methods
    }
}
 
// After: invariants live in the aggregate
public class Order {
    private static final int MAX_LINE_ITEMS = 50;
    
    public void addItem(ProductId productId, Quantity qty, Money unitPrice) {
        if (this.status != OrderStatus.DRAFT) {
            throw new OrderAlreadyConfirmedException(this.id);
        }
        if (this.lineItems.size() >= MAX_LINE_ITEMS) {
            throw new OrderLineItemLimitExceededException(this.id, MAX_LINE_ITEMS);
        }
        this.lineItems.add(new LineItem(productId, qty, unitPrice));
    }
}

class OrderRouter {
  constructor(
    private legacy: LegacyOrderService,
    private newImpl: OrderApplicationService,
    private flags: FeatureFlags,
    private divergenceLogger: DivergeLogger,
  ) {}
 
  async placeOrder(command: PlaceOrderCommand): Promise<OrderId> {
    if (this.flags.isEnabled('order-new-impl')) {
      return this.newImpl.placeOrder(command);
    }
 
    const legacyResult = await this.legacy.placeOrder(command);
 
    if (this.flags.isEnabled('order-shadow-mode')) {
      // Don't await — don't block the customer
      this.newImpl.placeOrder(command)
        .then(newResult => {
          if (newResult.value !== legacyResult.orderId) {
            this.divergenceLogger.log({ command, legacyResult, newResult });
          }
        })
        .catch(err => this.divergenceLogger.logError({ command, err }));
    }
 
    return new OrderId(legacyResult.orderId);
  }
}