DDD and Microservices Alignment — Deep Dive

graph TD
    subgraph Order Bounded Context
        OS[Order Service]
        ODB[(Order DB)]
    end
    subgraph Payment Bounded Context
        PS[Payment Service]
        PDB[(Payment DB)]
    end
    subgraph Inventory Bounded Context
        IS[Inventory Service]
        IDB[(Inventory DB)]
    end
    OS -->|API| PS
    OS -->|Events| IS

sequenceDiagram
    participant OA as Order Aggregate
    participant OS as Order Service
    participant K as Kafka
    participant IS as Inventory Service
    participant IA as Inventory Aggregate

    OA->>OS: OrderPlaced (domain event)
    OS->>K: Publish OrderPlaced (integration event)
    K->>IS: Consume OrderPlaced
    IS->>IA: reserveInventory()

// Integration event (published to Kafka)
public record OrderPlacedEvent(
    String eventId,
    String orderId,
    String customerId,
    BigDecimal totalAmount,
    String currency,
    List<OrderLineDto> items,
    Instant occurredAt,
    int version  // Schema version
) {}

graph LR
    subgraph Your Service
        DS[Domain Service]
        ACL[ACL Adapter]
    end
    EXT[External/Legacy Service]
    DS --> ACL
    ACL --> EXT

// ACL isolates your domain from external API
public class LegacyOrderAdapter implements OrderGateway {
    private final LegacyOrderClient legacyClient;

    @Override
    public Order fetchOrder(OrderId orderId) {
        // External API returns messy legacy format
        LegacyOrderResponse legacy = legacyClient.getOrder(orderId.value());

        // Translate to your clean domain model
        return new Order(
            new OrderId(legacy.getOrdNo()),
            mapStatus(legacy.getStatCd()),
            mapLines(legacy.getItms())
        );
    }
}

graph TD
    subgraph Order Service
        OA[Order Aggregate]
        OA --> OL[OrderLines]
        OA --> SA[ShippingAddress]
    end
    subgraph Inventory Service
        IA[Inventory Aggregate]
        IA --> SI[StockItem]
        IA --> RS[Reservation]
    end
    OA -->|OrderPlaced event| IA

// WRONG: Inventory service accessing Order aggregate
public class InventoryService {
    private final OrderRepository orderRepository;  // Crosses boundary!

    public void reserveForOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId);  // BAD
        // ...
    }
}

// RIGHT: Inventory service receives event with needed data
public class InventoryEventHandler {
    @KafkaListener(topics = "orders")
    public void handleOrderPlaced(OrderPlacedEvent event) {
        // Event contains all needed data
        inventory.reserve(event.items());
    }
}

graph TD
    subgraph Core Domain
        PRICE[Pricing Service - Custom]
        REC[Recommendation Service - Custom]
    end
    subgraph Supporting Domain
        ORD[Order Service]
        INV[Inventory Service]
    end
    subgraph Generic Domain
        AUTH[Auth0 - SaaS]
        EMAIL[SendGrid - SaaS]
        PAY[Stripe - SaaS]
    end

graph LR
    O[Order Service] -->|OrderPlaced| K[Kafka]
    K -->|OrderPlaced| I[Inventory Service]
    I -->|InventoryReserved| K
    K -->|InventoryReserved| P[Payment Service]
    P -->|PaymentCharged| K

graph TD
    S[Saga Orchestrator]
    S -->|ReserveInventory| I[Inventory Service]
    I -->|Reserved| S
    S -->|ChargePayment| P[Payment Service]
    P -->|Charged| S
    S -->|CreateShipment| SH[Shipping Service]

graph LR
    subgraph Order Service
        O[Order]
        O --> CN[Customer Name - copied]
    end
    subgraph Customer Service
        C[Customer - source of truth]
    end
    C -->|CustomerUpdated event| O

graph TD
    subgraph Monolith
        M1[Order Module]
        M2[Inventory Module]
        M3[Payment Module]
    end
    subgraph Extracted
        S1[Order Service]
    end
    M1 -.->|Extract| S1
    M2 --> M3
    S1 -->|API| M2