Aggregates & Entities in DDD

// Order aggregate — Order is the root; OrderLine is an internal entity
@Entity
@Table(name = "orders")
public class Order {   // Aggregate Root

    @Id
    private OrderId id;
    private CustomerId customerId;   // reference by ID (not the Customer object)
    private OrderStatus status;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderLine> lines = new ArrayList<>();

    private Money total;

    // All mutations go through root methods
    public void addLine(ProductId productId, int qty, Money price) {
        if (status != OrderStatus.DRAFT)
            throw new OrderNotEditableException(id);
        if (lines.size() >= 50)
            throw new TooManyLinesException(id);

        lines.add(new OrderLine(productId, qty, price));
        this.total = recalculateTotal();
    }

    public void place() {
        if (lines.isEmpty())
            throw new EmptyOrderException(id);
        this.status = OrderStatus.PLACED;
        registerEvent(new OrderPlaced(id, customerId, total));
    }

    private Money recalculateTotal() {
        return lines.stream()
            .map(OrderLine::lineTotal)
            .reduce(Money.ZERO, Money::add);
    }
}

// Anti-pattern: over-large aggregate
// Customer aggregate with all orders, addresses, payment methods, reviews
public class Customer {
    private List<Order> orders;       // ✗ wrong — Order is its own aggregate
    private List<Address> addresses;
    private List<PaymentMethod> paymentMethods;
    // Any write to Customer locks ALL this data — concurrency nightmare
}

// Correct: separate aggregates, reference by ID
public class Customer {
    private CustomerId id;
    private String email;
    private List<AddressId> addressIds;   // IDs only, not objects
}

public class Order {
    private OrderId id;
    private CustomerId customerId;        // reference Customer by ID
    // ...
}

// Eventual consistency between aggregates via Domain Events
// ✓ Order.place() → OrderPlaced event
// ✓ LoyaltyService subscribes to OrderPlaced → updates points asynchronously
// ✗ NOT: order.place() + customer.addPoints() in same ACID transaction

// Repository interface — domain layer
public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomer(CustomerId customerId);
    void save(Order order);
    void delete(OrderId id);
}

// Rule: no repository for OrderLine — access via Order
// ✗ orderLineRepository.findByOrderId(orderId);  — wrong
// ✓ orderRepository.findById(orderId)
//       .map(order -> order.getLines())           — correct

// Application service — load aggregate, call root method, save
@Service
@Transactional
public class OrderApplicationService {

    public void addLineToOrder(AddLineCommand cmd) {
        Order order = orderRepository.findById(cmd.orderId())
            .orElseThrow(() -> new OrderNotFoundException(cmd.orderId()));

        order.addLine(cmd.productId(), cmd.quantity(), cmd.unitPrice());

        orderRepository.save(order);
        order.pullDomainEvents().forEach(eventPublisher::publish);
    }
}