Domain-Driven Design

// Entity: identity-based equality
type Order struct {
    ID        OrderID      // stable identity
    CustomerID CustomerID
    Items     []LineItem
    Status    OrderStatus
    events    []DomainEvent  // internal, not exported
}

// Equality based on ID, not attributes
func (o *Order) Equals(other *Order) bool {
    return o.ID == other.ID
}

// Behavior encapsulated — not a bag of getters
func (o *Order) AddItem(product ProductID, qty int, price Money) error {
    if o.Status != OrderStatusDraft {
        return ErrOrderNotEditable
    }
    o.Items = append(o.Items, LineItem{product, qty, price})
    return nil
}

// Value Object: no identity, immutable, equality by value
type Money struct {
    amount   int64    // stored in cents
    currency string
}

func NewMoney(amount int64, currency string) (Money, error) {
    if amount < 0 {
        return Money{}, ErrNegativeAmount
    }
    return Money{amount: amount, currency: currency}, nil
}

// Returns a NEW Money — immutable; never mutates self
func (m Money) Add(other Money) (Money, error) {
    if m.currency != other.currency {
        return Money{}, ErrCurrencyMismatch
    }
    return Money{m.amount + other.amount, m.currency}, nil
}

// Equality = all attributes equal
func (m Money) Equals(other Money) bool {
    return m.amount == other.amount && m.currency == other.currency
}

// Domain layer — pure interface, no DB details
type OrderRepository interface {
    FindByID(ctx context.Context, id OrderID) (*Order, error)
    Save(ctx context.Context, order *Order) error
    FindByCustomer(ctx context.Context, cID CustomerID) ([]*Order, error)
}

// Infrastructure layer — Postgres implementation
type PostgresOrderRepo struct { db *pgxpool.Pool }

func (r *PostgresOrderRepo) FindByID(ctx context.Context, id OrderID) (*Order, error) {
    // Reconstruct full aggregate from DB rows
    row := r.db.QueryRow(ctx, `SELECT * FROM orders WHERE id=$1`, id)
    return scanOrder(row)
}

// TransferService: involves two Accounts — belongs to neither
type TransferService struct {
    accounts AccountRepository
}

func (s *TransferService) Transfer(
    ctx context.Context,
    from, to AccountID,
    amount Money,
) error {
    src, _ := s.accounts.FindByID(ctx, from)
    dst, _ := s.accounts.FindByID(ctx, to)

    if err := src.Debit(amount); err != nil { return err }
    dst.Credit(amount)

    s.accounts.Save(ctx, src)
    s.accounts.Save(ctx, dst)
    return nil
}

// Domain events — past tense, immutable
type DomainEvent interface {
    OccurredAt() time.Time
    AggregateID() string
}

type OrderPlaced struct {
    OrderID    OrderID
    CustomerID CustomerID
    Total      Money
    At         time.Time
}
func (e OrderPlaced) OccurredAt() time.Time { return e.At }
func (e OrderPlaced) AggregateID() string   { return string(e.OrderID) }

// Aggregate emits events internally during state transitions
func (o *Order) Place() error {
    if len(o.Items) == 0 {
        return ErrEmptyOrder
    }
    o.Status = StatusPlaced
    o.events = append(o.events, OrderPlaced{
        OrderID:    o.ID,
        CustomerID: o.CustomerID,
        Total:      o.Total(),
        At:         time.Now(),
    })
    return nil
}

// Application service dispatches after save
func (s *OrderService) PlaceOrder(ctx context.Context, cmd PlaceOrderCmd) error {
    order, _ := s.repo.FindByID(ctx, cmd.OrderID)
    order.Place()
    s.repo.Save(ctx, order)
    for _, evt := range order.PullEvents() {
        s.bus.Publish(ctx, evt)   // dispatch after commit
    }
    return nil
}

// External Stripe model (we must NOT let this pollute our domain)
type StripeCharge struct {
    ID       string
    Amount   int
    Currency string
    Status   string  // "succeeded", "pending", "failed"
}

// Our domain model — independent, speaks our language
type Payment struct {
    PaymentID   PaymentID
    Amount      Money
    Status      PaymentStatus  // Completed | Pending | Failed
}

// ACL: translates Stripe → our domain — lives in infra layer
type StripePaymentACL struct {
    client *stripe.Client
}

func (acl *StripePaymentACL) Charge(ctx context.Context, amount Money) (*Payment, error) {
    charge, err := acl.client.CreateCharge(&stripe.ChargeParams{
        Amount:   stripe.Int64(amount.Cents()),
        Currency: stripe.String(amount.Currency()),
    })
    if err != nil { return nil, err }

    // Translate external model → our domain model
    return &Payment{
        PaymentID: PaymentID(charge.ID),
        Amount:    amount,
        Status:    translateStatus(charge.Status),
    }, nil
}

func translateStatus(s string) PaymentStatus {
    switch s {
    case "succeeded": return PaymentCompleted
    case "pending":   return PaymentPending
    default:         return PaymentFailed
    }
}