+-------------------+     +-------------------+
  |   Sales Context   |     |  Shipping Context |
  |                   |     |                   |
  |  Customer:        |     |  Customer:        |
  |  - Name           |     |  - Address        |
  |  - Credit Limit   |     |  - Delivery Prefs |
  |  - Purchase Hist  |     |  - Contact Phone  |
  +-------------------+     +-------------------+

class Customer:
    """Entity: identified by customer_id across its lifecycle."""

    def __init__(self, customer_id: CustomerId, name: str, email: Email):
        self._id = customer_id
        self._name = name
        self._email = email
        self._orders: List[OrderId] = []

    @property
    def id(self) -> CustomerId:
        return self._id

    def change_email(self, new_email: Email) -> None:
        # Business rule: email change requires verification
        self._email = new_email
        self._email_verified = False

    def __eq__(self, other):
        if not isinstance(other, Customer):
            return False
        return self._id == other._id

    def __hash__(self):
        return hash(self._id)

from dataclasses import dataclass
from typing import Self

@dataclass(frozen=True)
class Money:
    """Value Object: immutable, compared by value."""

    amount: Decimal
    currency: str

    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("Amount cannot be negative")
        if len(self.currency) != 3:
            raise ValueError("Currency must be ISO 4217 code")

    def add(self, other: Self) -> Self:
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

    def multiply(self, factor: Decimal) -> Self:
        return Money(self.amount * factor, self.currency)


@dataclass(frozen=True)
class Address:
    """Value Object: complete address as a single concept."""

    street: str
    city: str
    postal_code: str
    country: str

    def format_for_shipping(self) -> str:
        return f"{self.street}\n{self.city}, {self.postal_code}\n{self.country}"

class Order:
    """Aggregate Root: enforces invariants for the entire order."""

    def __init__(self, order_id: OrderId, customer_id: CustomerId):
        self._id = order_id
        self._customer_id = customer_id
        self._items: List[OrderLine] = []
        self._status = OrderStatus.DRAFT

    def add_item(self, product_id: ProductId, quantity: int, unit_price: Money) -> None:
        """Business logic protected by the aggregate root."""
        if self._status != OrderStatus.DRAFT:
            raise InvalidOperationError("Cannot modify confirmed order")

        existing = self._find_item(product_id)
        if existing:
            existing.increase_quantity(quantity)
        else:
            self._items.append(OrderLine(product_id, quantity, unit_price))

    def confirm(self) -> None:
        """Transition with business rules."""
        if not self._items:
            raise InvalidOperationError("Cannot confirm empty order")
        if self._total() > Money(Decimal("10000"), "USD"):
            raise InvalidOperationError("Orders over $10,000 require approval")
        self._status = OrderStatus.CONFIRMED

    def _total(self) -> Money:
        return sum((item.subtotal() for item in self._items), Money(Decimal("0"), "USD"))


class OrderLine:
    """Entity within the Order aggregate (not externally accessible)."""

    def __init__(self, product_id: ProductId, quantity: int, unit_price: Money):
        self._product_id = product_id
        self._quantity = quantity
        self._unit_price = unit_price

    def subtotal(self) -> Money:
        return self._unit_price.multiply(Decimal(self._quantity))

    def increase_quantity(self, amount: int) -> None:
        self._quantity += amount

from dataclasses import dataclass
from datetime import datetime
from uuid import UUID

@dataclass(frozen=True)
class DomainEvent:
    """Base class for all domain events."""
    event_id: UUID
    occurred_at: datetime


@dataclass(frozen=True)
class OrderConfirmed(DomainEvent):
    """Event: order has been confirmed by customer."""
    order_id: OrderId
    customer_id: CustomerId
    total_amount: Money


@dataclass(frozen=True)
class PaymentReceived(DomainEvent):
    """Event: payment was successfully processed."""
    order_id: OrderId
    payment_id: PaymentId
    amount: Money
    method: PaymentMethod

from abc import ABC, abstractmethod
from typing import Optional

class OrderRepository(ABC):
    """Repository interface: part of the domain layer."""

    @abstractmethod
    def find_by_id(self, order_id: OrderId) -> Optional[Order]:
        pass

    @abstractmethod
    def save(self, order: Order) -> None:
        pass

    @abstractmethod
    def find_by_customer(self, customer_id: CustomerId) -> List[Order]:
        pass


class SqlOrderRepository(OrderRepository):
    """Infrastructure implementation of the repository."""

    def __init__(self, session: Session):
        self._session = session

    def find_by_id(self, order_id: OrderId) -> Optional[Order]:
        # Reconstruct aggregate from persistence
        row = self._session.query(OrderModel).filter_by(id=order_id.value).first()
        if not row:
            return None
        return self._to_domain(row)

    def save(self, order: Order) -> None:
        # Persist aggregate state
        model = self._to_model(order)
        self._session.merge(model)

class PricingService:
    """Domain Service: calculates prices across multiple aggregates."""

    def __init__(self,
                 discount_policy: DiscountPolicy,
                 tax_calculator: TaxCalculator):
        self._discount_policy = discount_policy
        self._tax_calculator = tax_calculator

    def calculate_order_total(self, order: Order, customer: Customer) -> Money:
        subtotal = order.subtotal()
        discount = self._discount_policy.calculate_discount(customer, subtotal)
        after_discount = subtotal.subtract(discount)
        tax = self._tax_calculator.calculate(after_discount, customer.shipping_address)
        return after_discount.add(tax)

class OrderFactory:
    """Factory: encapsulates complex order creation."""

    def __init__(self, id_generator: IdGenerator):
        self._id_generator = id_generator

    def create_from_cart(self, cart: ShoppingCart, customer: Customer) -> Order:
        order_id = self._id_generator.generate_order_id()
        order = Order(order_id, customer.id)

        for item in cart.items:
            order.add_item(item.product_id, item.quantity, item.unit_price)

        return order

    def create_recurring_order(self,
                                subscription: Subscription,
                                customer: Customer) -> Order:
        order_id = self._id_generator.generate_order_id()
        order = Order(order_id, customer.id)
        order.mark_as_recurring(subscription.id)

        for product in subscription.products:
            order.add_item(product.id, product.quantity, product.current_price)

        return order

from abc import ABC, abstractmethod
from typing import List

class EventSourcedAggregate(ABC):
    """Base class for event-sourced aggregates."""

    def __init__(self):
        self._uncommitted_events: List[DomainEvent] = []
        self._version = 0

    def apply(self, event: DomainEvent) -> None:
        """Apply an event and record it."""
        self._apply_event(event)
        self._uncommitted_events.append(event)

    @abstractmethod
    def _apply_event(self, event: DomainEvent) -> None:
        """Handle state change for the event."""
        pass

    def load_from_history(self, events: List[DomainEvent]) -> None:
        """Reconstitute aggregate from event stream."""
        for event in events:
            self._apply_event(event)
            self._version += 1

    def get_uncommitted_events(self) -> List[DomainEvent]:
        return list(self._uncommitted_events)

    def clear_uncommitted_events(self) -> None:
        self._uncommitted_events.clear()


class Order(EventSourcedAggregate):
    """Event-sourced Order aggregate."""

    def __init__(self, order_id: OrderId = None):
        super().__init__()
        self._id = order_id
        self._items = {}
        self._status = None

    def create(self, order_id: OrderId, customer_id: CustomerId) -> None:
        self.apply(OrderCreated(
            event_id=uuid4(),
            occurred_at=datetime.utcnow(),
            order_id=order_id,
            customer_id=customer_id
        ))

    def add_item(self, product_id: ProductId, quantity: int, price: Money) -> None:
        if self._status != OrderStatus.DRAFT:
            raise InvalidOperationError("Cannot modify non-draft order")
        self.apply(ItemAddedToOrder(
            event_id=uuid4(),
            occurred_at=datetime.utcnow(),
            order_id=self._id,
            product_id=product_id,
            quantity=quantity,
            unit_price=price
        ))

    def _apply_event(self, event: DomainEvent) -> None:
        match event:
            case OrderCreated():
                self._id = event.order_id
                self._customer_id = event.customer_id
                self._status = OrderStatus.DRAFT
            case ItemAddedToOrder():
                self._items[event.product_id] = OrderLine(
                    event.product_id,
                    event.quantity,
                    event.unit_price
                )
            case OrderConfirmed():
                self._status = OrderStatus.CONFIRMED

class EventStore:
    """Append-only store for domain events."""

    def __init__(self, connection):
        self._connection = connection

    def append(self,
               aggregate_id: str,
               events: List[DomainEvent],
               expected_version: int) -> None:
        """Append events with optimistic concurrency."""
        current_version = self._get_version(aggregate_id)
        if current_version != expected_version:
            raise ConcurrencyError(
                f"Expected version {expected_version}, found {current_version}"
            )

        for i, event in enumerate(events):
            self._connection.execute(
                """
                INSERT INTO events (aggregate_id, version, event_type, data, occurred_at)
                VALUES (?, ?, ?, ?, ?)
                """,
                (aggregate_id, expected_version + i + 1,
                 type(event).__name__, serialize(event), event.occurred_at)
            )

    def get_events(self, aggregate_id: str) -> List[DomainEvent]:
        """Retrieve all events for an aggregate."""
        rows = self._connection.execute(
            "SELECT event_type, data FROM events WHERE aggregate_id = ? ORDER BY version",
            (aggregate_id,)
        ).fetchall()
        return [deserialize(row['event_type'], row['data']) for row in rows]

                    +-----------------+
                    |     Client      |
                    +--------+--------+
                             |
            +----------------+----------------+
            |                                 |
            v                                 v
    +-------+-------+                 +-------+-------+
    | Command Side  |                 |  Query Side   |
    +-------+-------+                 +-------+-------+
            |                                 |
            v                                 v
    +-------+-------+                 +-------+-------+
    | Write Model   |   --------->   | Read Model    |
    | (Aggregates)  |    Events      | (Projections) |
    +-------+-------+                 +-------+-------+
            |                                 |
            v                                 v
    +-------+-------+                 +-------+-------+
    | Event Store   |                 | Read Database |
    +---------------+                 +---------------+

from dataclasses import dataclass

@dataclass(frozen=True)
class CreateOrderCommand:
    """Command to create a new order."""
    customer_id: str
    items: List[OrderItemDto]


class CreateOrderHandler:
    """Command handler: orchestrates the use case."""

    def __init__(self,
                 order_repository: OrderRepository,
                 customer_repository: CustomerRepository,
                 event_publisher: EventPublisher):
        self._orders = order_repository
        self._customers = customer_repository
        self._events = event_publisher

    def handle(self, command: CreateOrderCommand) -> OrderId:
        customer = self._customers.find_by_id(CustomerId(command.customer_id))
        if not customer:
            raise CustomerNotFoundError(command.customer_id)

        order = Order.create(customer.id)
        for item in command.items:
            order.add_item(ProductId(item.product_id), item.quantity)

        self._orders.save(order)
        self._events.publish(order.get_uncommitted_events())

        return order.id

class OrderSummaryProjection:
    """Read model projection: denormalized for fast queries."""

    def __init__(self, read_db: ReadDatabase):
        self._db = read_db

    def on_order_created(self, event: OrderCreated) -> None:
        self._db.execute(
            """
            INSERT INTO order_summaries
            (order_id, customer_id, status, created_at, total_amount, item_count)
            VALUES (?, ?, 'draft', ?, 0, 0)
            """,
            (event.order_id.value, event.customer_id.value, event.occurred_at)
        )

    def on_item_added(self, event: ItemAddedToOrder) -> None:
        self._db.execute(
            """
            UPDATE order_summaries
            SET item_count = item_count + 1,
                total_amount = total_amount + ?
            WHERE order_id = ?
            """,
            (event.quantity * event.unit_price.amount, event.order_id.value)
        )


class OrderQueryService:
    """Query service: reads from denormalized read model."""

    def __init__(self, read_db: ReadDatabase):
        self._db = read_db

    def get_customer_orders(self, customer_id: str) -> List[OrderSummaryDto]:
        rows = self._db.query(
            """
            SELECT order_id, status, created_at, total_amount, item_count
            FROM order_summaries
            WHERE customer_id = ?
            ORDER BY created_at DESC
            """,
            (customer_id,)
        )
        return [OrderSummaryDto(**row) for row in rows]

    def get_order_details(self, order_id: str) -> OrderDetailsDto:
        # Fetch from pre-computed read model
        pass