// ПЛОХО: дублирование логики валидации в каждом сервисе
func validateUUID(s string) error { ... }

// ХОРОШО: protovalidate в .proto + interceptor (валидация генерируется)
// string id = 1 [(buf.validate.field).string.uuid = true];

billing-service/
├── internal/
│   ├── domain/          # Бизнес-логика (чистая, без зависимостей)
│   │   ├── account.go   # Account aggregate
│   │   ├── transaction.go
│   │   └── ledger.go    # Двойная запись
│   ├── app/             # Application-слой (use cases)
│   │   ├── register_payment.go
│   │   ├── charge_account.go
│   │   └── get_balance.go
│   ├── infra/           # Инфраструктура (БД, RabbitMQ, внешние API)
│   │   ├── postgres/
│   │   │   ├── account_repo.go
│   │   │   └── outbox_repo.go
│   │   └── rabbitmq/
│   │       └── publisher.go
│   └── port/            # Входные точки (ConnectRPC handlers, consumers)
│       ├── grpc/
│       │   └── billing_handler.go
│       └── consumer/
│           └── commands_consumer.go
├── cmd/
│   └── billing/
│       └── main.go
└── proto/               # Ссылка на buf.build BSR

// Интерфейс (закрыт для модификации)
type NASProvisioner interface {
    ApplyProfile(ctx context.Context, cmd ApplyProfileCommand) error
    RemoveProfile(ctx context.Context, cmd RemoveProfileCommand) error
    SendCoA(ctx context.Context, cmd CoACommand) error
}

// Реализации (открыты для расширения — добавляем новый вендор)
type MikrotikProvisioner struct { ... }
type HuaweiProvisioner struct { ... }
type JuniperProvisioner struct { ... }
type EltexProvisioner struct { ... }  // Новый вендор = новый файл, 0 изменений в core

// ПЛОХО: "God interface"
type Repository interface {
    GetAccount(ctx context.Context, id string) (*Account, error)
    ListAccounts(ctx context.Context) ([]*Account, error)
    CreateAccount(ctx context.Context, a *Account) error
    UpdateAccount(ctx context.Context, a *Account) error
    DeleteAccount(ctx context.Context, id string) error
    GetTransaction(ctx context.Context, id string) (*Transaction, error)
    ListTransactions(ctx context.Context, accountID string) ([]*Transaction, error)
    // ... ещё 20 методов
}

// ХОРОШО: маленькие, сфокусированные интерфейсы
type AccountReader interface {
    GetAccount(ctx context.Context, id string) (*Account, error)
    ListAccounts(ctx context.Context, filter AccountFilter) ([]*Account, error)
}

type AccountWriter interface {
    SaveAccount(ctx context.Context, a *Account) error
}

type TransactionReader interface {
    ListTransactions(ctx context.Context, accountID string, filter TxFilter) ([]*Transaction, error)
}

// domain/account.go
type Account struct {
    id           string
    balance      Money
    creditLimit  Money
    status       AccountStatus
    transactions []Transaction
    events       []DomainEvent  // Накопленные события
}

// Бизнес-метод на Aggregate Root
func (a *Account) Credit(amount Money, source string, idempotencyKey string) error {
    if amount.IsNegative() {
        return ErrInvalidAmount
    }

    tx := Transaction{
        ID:        uuid.New().String(),
        Amount:    amount,
        Type:      TransactionTypeCredit,
        Source:    source,
        CreatedAt: time.Now(),
    }

    a.balance = a.balance.Add(amount)
    a.transactions = append(a.transactions, tx)

    // Доменное событие — будет опубликовано через Outbox после коммита
    a.events = append(a.events, PaymentReceivedEvent{
        AccountID: a.id,
        Amount:    amount,
        PaymentID: tx.ID,
        Source:    source,
    })

    return nil
}

// Собрать и очистить накопленные события
func (a *Account) PopEvents() []DomainEvent {
    events := a.events
    a.events = nil
    return events
}

// domain/money.go
type Money struct {
    amount   decimal.Decimal
    currency string
}

func NewMoney(amount decimal.Decimal, currency string) (Money, error) {
    if currency == "" {
        return Money{}, ErrEmptyCurrency
    }
    return Money{amount: amount, currency: currency}, nil
}

func (m Money) Add(other Money) Money {
    if m.currency != other.currency {
        panic("currency mismatch") // Invariant violation
    }
    return Money{amount: m.amount.Add(other.amount), currency: m.currency}
}

func (m Money) IsNegative() bool {
    return m.amount.IsNegative()
}

// domain/events.go
type DomainEvent interface {
    EventType() string
    AggregateID() string
}

type PaymentReceivedEvent struct {
    AccountID string
    Amount    Money
    PaymentID string
    Source    string
}

func (e PaymentReceivedEvent) EventType() string    { return "payment.received" }
func (e PaymentReceivedEvent) AggregateID() string  { return e.AccountID }

// app/ports.go
type UnitOfWork interface {
    // Begin начинает транзакцию и возвращает контекст с tx.
    Begin(ctx context.Context) (context.Context, error)
    // Commit фиксирует транзакцию.
    Commit(ctx context.Context) error
    // Rollback откатывает транзакцию.
    Rollback(ctx context.Context) error
}

// app/register_payment.go
type RegisterPaymentUseCase struct {
    uow          UnitOfWork
    accounts     AccountRepository   // interface
    outbox       OutboxRepository    // interface
}

func (uc *RegisterPaymentUseCase) Execute(ctx context.Context, cmd RegisterPaymentCommand) error {
    ctx, err := uc.uow.Begin(ctx)
    if err != nil {
        return fmt.Errorf("begin tx: %w", err)
    }
    defer uc.uow.Rollback(ctx) // no-op если уже закоммичено

    // 1. Загрузить Aggregate
    account, err := uc.accounts.GetByID(ctx, cmd.AccountID)
    if err != nil {
        return fmt.Errorf("get account: %w", err)
    }

    // 2. Бизнес-логика (на Aggregate Root)
    if err := account.Credit(cmd.Amount, cmd.Source, cmd.IdempotencyKey); err != nil {
        return fmt.Errorf("credit: %w", err)
    }

    // 3. Сохранить Aggregate
    if err := uc.accounts.Save(ctx, account); err != nil {
        return fmt.Errorf("save account: %w", err)
    }

    // 4. Сохранить доменные события в Outbox (в той же транзакции!)
    for _, event := range account.PopEvents() {
        if err := uc.outbox.Save(ctx, event); err != nil {
            return fmt.Errorf("save outbox: %w", err)
        }
    }

    // 5. Коммит (атомарно: Account + Outbox)
    if err := uc.uow.Commit(ctx); err != nil {
        return fmt.Errorf("commit: %w", err)
    }

    return nil
}

// app/ports.go (интерфейс)
type AccountRepository interface {
    GetByID(ctx context.Context, id string) (*domain.Account, error)
    Save(ctx context.Context, account *domain.Account) error
}

// infra/postgres/account_repo.go (реализация)
type PostgresAccountRepository struct {
    db *pgxpool.Pool
}

func (r *PostgresAccountRepository) GetByID(ctx context.Context, id string) (*domain.Account, error) {
    // Извлекаем tx из контекста (Unit of Work)
    tx := extractTx(ctx)
    row := tx.QueryRow(ctx,
        `SELECT id, balance, credit_limit, status FROM accounts WHERE id = $1 FOR UPDATE`,
        id,
    )
    // ... маппинг в domain.Account
}

func (r *PostgresAccountRepository) Save(ctx context.Context, account *domain.Account) error {
    tx := extractTx(ctx)
    _, err := tx.Exec(ctx,
        `UPDATE accounts SET balance = $1, status = $2, updated_at = now() WHERE id = $3`,
        account.Balance(), account.Status(), account.ID(),
    )
    return err
}

┌─────────────────────────────────────────┐
│              Ports (вход)               │  ConnectRPC handlers, RabbitMQ consumers
├─────────────────────────────────────────┤
│           Application (use cases)       │  Оркестрация: UoW + Repo + Domain
├─────────────────────────────────────────┤
│              Domain (ядро)              │  Aggregates, Value Objects, Events
├─────────────────────────────────────────┤
│         Infrastructure (адаптеры)       │  PostgreSQL, RabbitMQ, External APIs
└─────────────────────────────────────────┘

Зависимости: Ports → Application → Domain ← Infrastructure

// Доменные ошибки (бизнес-логика)
var (
    ErrAccountNotFound    = errors.New("account not found")
    ErrInsufficientFunds  = errors.New("insufficient funds")
    ErrDuplicatePayment   = errors.New("duplicate payment")
)

// Use case оборачивает ошибки с контекстом
func (uc *ChargeAccountUseCase) Execute(ctx context.Context, cmd ChargeCommand) error {
    account, err := uc.accounts.GetByID(ctx, cmd.AccountID)
    if err != nil {
        return fmt.Errorf("charge account %s: %w", cmd.AccountID, err)
    }
    // ...
}

// ConnectRPC handler маппит доменные ошибки → gRPC коды
func domainErrorToConnect(err error) *connect.Error {
    switch {
    case errors.Is(err, domain.ErrAccountNotFound):
        return connect.NewError(connect.CodeNotFound, err)
    case errors.Is(err, domain.ErrInsufficientFunds):
        return connect.NewError(connect.CodeFailedPrecondition, err)
    case errors.Is(err, domain.ErrDuplicatePayment):
        return connect.NewError(connect.CodeAlreadyExists, err)
    default:
        return connect.NewError(connect.CodeInternal, err)
    }
}

// Конфигурация через переменные окружения (12-Factor App)
type Config struct {
    Port        int    `env:"PORT" envDefault:"8080"`
    DatabaseURL string `env:"DATABASE_URL,required"`
    RabbitMQURL string `env:"RABBITMQ_URL,required"`
    LogLevel    string `env:"LOG_LEVEL" envDefault:"info"`
}

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    // ... инициализация

    g, ctx := errgroup.WithContext(ctx)
    g.Go(func() error { return grpcServer.Serve(ctx) })
    g.Go(func() error { return rabbitConsumer.Run(ctx) })
    g.Go(func() error { return outboxRelay.Run(ctx) })

    if err := g.Wait(); err != nil {
        slog.Error("service stopped", "error", err)
    }
}