DDD (Domain-Driven Design)

# плохо: технический язык
order.status = 4
order.save()

# хорошо: язык бизнеса
order.cancel(reason=CancelReason.OUT_OF_STOCK)

# анемичная: правило живёт снаружи и легко обходится
if order.status == 'new' and order.total > 0:
    order.status = 'paid'

# богатая: правило внутри объекта
class Order:
    def pay(self, amount):
        if self.status != Status.NEW:
            raise OrderAlreadyPaid(self.id)
        if amount != self.total:
            raise WrongPaymentAmount(amount, self.total)
        self.status = Status.PAID

class CrmCustomerTranslator:
    """ACL: CRM отдаёт свой формат, домен видит только Customer."""

    def __init__(self, crm_client):
        self._crm = crm_client

    def get_customer(self, customer_id):
        raw = self._crm.fetch_client(customer_id)
        return Customer(
            id=CustomerId(raw['ClientID']),
            email=Email(raw['ContactInfo']['EMail']),
            is_vip=raw['SegmentCode'] in ('VIP', 'GOLD'),
        )

class User:
    def __init__(self, user_id, email):
        self.id = user_id
        self.email = email

    def change_email(self, new_email):
        self.email = new_email

    def __eq__(self, other):
        return isinstance(other, User) and self.id == other.id

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

from dataclasses import dataclass
from decimal import Decimal

@dataclass(frozen=True)
class Money:
    amount: Decimal
    currency: str

    def __post_init__(self):
        if self.amount < 0:
            raise ValueError('Сумма не может быть отрицательной')

    def __add__(self, other):
        if other.currency != self.currency:
            raise ValueError('Разные валюты')
        return Money(self.amount + other.amount, self.currency)

class Order:                     # корень агрегата
    def __init__(self, order_id):
        self.id = order_id
        self._lines = []         # OrderLine — внутренняя часть агрегата

    def add_line(self, product_id, qty, price):
        if len(self._lines) >= 50:
            raise TooManyLines()
        self._lines.append(OrderLine(product_id, qty, price))

    @property
    def total(self):
        return sum((line.subtotal for line in self._lines), Money.zero())

# плохо: объектная ссылка на чужой агрегат
class Order:
    customer: Customer

# хорошо: ссылка по id
class Order:
    customer_id: CustomerId

class Order:
    @classmethod
    def create(cls, customer_id, cart):
        if cart.is_empty():
            raise EmptyCart()
        order = cls(OrderId.new(), customer_id)
        for item in cart.items:
            order.add_line(item.product_id, item.qty, item.price)
        order._record(OrderPlaced(order.id, customer_id))
        return order

class OrderRepository(Protocol):
    def get(self, order_id: OrderId) -> Order: ...
    def add(self, order: Order) -> None: ...

class SqlAlchemyOrderRepository:
    def __init__(self, session):
        self._session = session

    def get(self, order_id):
        return self._session.get(Order, order_id)

    def add(self, order):
        self._session.add(order)

@dataclass(frozen=True)
class OrderPlaced:
    order_id: OrderId
    customer_id: CustomerId
    total: Money
    occurred_at: datetime

class AggregateRoot:
    def __init__(self):
        self._events = []

    def _record(self, event):
        self._events.append(event)

    def pull_events(self):
        events, self._events = self._events, []
        return events

class Order(AggregateRoot):
    def pay(self, payment):
        ...
        self.status = Status.PAID
        self._record(OrderPaid(self.id, payment.amount))

# прикладной сервис
with uow:
    order = uow.orders.get(order_id)
    order.pay(payment)
    uow.commit()
for event in order.pull_events():
    bus.publish(event)

OrderPaid (доменное, внутри «Заказов»)
    → обработчик внутри контекста
    → публикует OrderPaidV1 (интеграционное) в Kafka
    → «Склад» резервирует товар, «Лояльность» начисляет баллы

with uow:
    order.pay(payment)
    uow.orders.add(order)
    uow.outbox.add_all(order.pull_events())   # та же транзакция
    uow.commit()

Frameworks & Drivers (БД, веб, UI)
  └─ Interface Adapters (контроллеры, репозитории)
       └─ Application / Use Cases
            └─ Domain / Entities

class SqlAlchemyUnitOfWork:
    def __init__(self, session_factory):
        self._session_factory = session_factory

    def __enter__(self):
        self.session = self._session_factory()
        self.orders = SqlAlchemyOrderRepository(self.session)
        return self

    def __exit__(self, exc_type, exc, tb):
        self.session.rollback()   # без явного commit ничего не сохранится
        self.session.close()

    def commit(self):
        self.session.commit()

@dataclass(frozen=True)
class CancelOrder:                    # команда — входные данные сценария
    order_id: str
    reason: str

class CancelOrderHandler:
    def __init__(self, uow, bus):
        self._uow = uow
        self._bus = bus

    def __call__(self, cmd: CancelOrder):
        with self._uow as uow:
            order = uow.orders.get(OrderId(cmd.order_id))
            if order is None:
                raise OrderNotFound(cmd.order_id)
            order.cancel(CancelReason(cmd.reason))   # правила — внутри агрегата
            uow.commit()
        for event in order.pull_events():
            self._bus.publish(event)

# infrastructure/orm.py
mapper_registry.map_imperatively(Order, orders_table, properties={
    '_lines': relationship(OrderLine),
})

OrderPlaced  → ReserveStock
StockReserved → ChargePayment
PaymentFailed → ReleaseStock, CancelOrder   (компенсация)
PaymentCharged → ScheduleDelivery

updated = session.execute(
    update(orders)
    .where(orders.c.id == order.id, orders.c.version == order.version)
    .values(status=order.status, version=order.version + 1)
).rowcount
if updated == 0:
    raise ConcurrencyError(order.id)

Account #42:
  AccountOpened(owner=Аня)
  MoneyDeposited(100)
  MoneyWithdrawn(30)
→ баланс = 70

class OverdueInvoice:
    def __init__(self, today):
        self.today = today

    def is_satisfied_by(self, invoice):
        return not invoice.is_paid and invoice.due_date < self.today

class VipCustomer:
    def is_satisfied_by(self, customer):
        return customer.total_spent >= Money(100_000, 'RUB')

def test_cannot_pay_cancelled_order():
    order = make_order(total=Money(500, 'RUB'))
    order.cancel(CancelReason.CUSTOMER_REQUEST)

    with pytest.raises(OrderCancelled):
        order.pay(Payment(Money(500, 'RUB')))

def test_paying_records_event():
    order = make_order(total=Money(500, 'RUB'))
    order.pay(Payment(Money(500, 'RUB')))

    assert order.pull_events() == [OrderPaid(order.id, Money(500, 'RUB'))]

PlaceOrder → OrderPlaced
  → Склад: резерв     → StockReserved / StockShortage
  → Оплата: списание  → PaymentCaptured / PaymentFailed
  → Заказ: mark_paid  → OrderPaid → Доставка: создать отправление
Ошибка на любом шаге → компенсация: снять резерв, отменить заказ.