Domain-Driven Architecture #

// ✗ ANTI-PATTERN: technical language that does not represent the domain
func (s *LoanService) UpdateLoanRecord(id string, status int, reviewerID string) error {
    return s.db.Exec("UPDATE loans SET status = $1, reviewer = $2 WHERE id = $3",
        status, reviewerID, id)
}

// ✓ CORRECT: Ubiquitous Language — code speaks the business language
func (l *Loan) ApproveBy(reviewer *Reviewer) error {
    if l.status != LoanStatusPendingReview {
        return ErrLoanNotPendingReview
    }
    if !reviewer.HasAuthority(l.amount) {
        return ErrInsufficientReviewerAuthority
    }
    l.status = LoanStatusApproved
    l.approvedBy = reviewer.ID()
    l.approvedAt = time.Now()
    l.recordEvent(LoanApprovedEvent{LoanID: l.id, ReviewerID: reviewer.ID()})
    return nil
}

package domain

import (
	"errors"
	"time"
)

// Loan is an entity with a unique identity
type Loan struct {
	id          LoanID
	applicantID ApplicantID
	amount      Money
	status      LoanStatus
	term        LoanTerm
	appliedAt   time.Time
	approvedBy  *ReviewerID
	approvedAt  *time.Time
	events      []DomainEvent
}

// LoanID is a strongly-typed ID — prevents bugs from misused strings
type LoanID string
type ApplicantID string
type ReviewerID string

type LoanStatus string
const (
	LoanStatusDraft         LoanStatus = "draft"
	LoanStatusPendingReview LoanStatus = "pending_review"
	LoanStatusApproved      LoanStatus = "approved"
	LoanStatusRejected      LoanStatus = "rejected"
	LoanStatusDisbursed     LoanStatus = "disbursed"
)

// NewLoan is a factory function enforcing creation invariants
func NewLoan(applicantID ApplicantID, amount Money, term LoanTerm) (*Loan, error) {
	if amount.IsZeroOrNegative() {
		return nil, errors.New("loan amount must be greater than zero")
	}
	if !term.IsValid() {
		return nil, errors.New("invalid loan term")
	}

	loan := &Loan{
		id:          LoanID(generateID()),
		applicantID: applicantID,
		amount:      amount,
		status:      LoanStatusDraft,
		term:        term,
		appliedAt:   time.Now(),
	}
	loan.recordEvent(LoanCreatedEvent{LoanID: loan.id})
	return loan, nil
}

// Submit submits the loan for review — enforcing the business state machine
func (l *Loan) Submit() error {
	if l.status != LoanStatusDraft {
		return errors.New("only draft loans can be submitted")
	}
	l.status = LoanStatusPendingReview
	l.recordEvent(LoanSubmittedEvent{LoanID: l.id})
	return nil
}

// Approve approves the loan — contains the approval business rules
func (l *Loan) ApproveBy(reviewerID ReviewerID, maxAuthority Money) error {
	if l.status != LoanStatusPendingReview {
		return errors.New("only pending review loans can be approved")
	}
	if l.amount.GreaterThan(maxAuthority) {
		return errors.New("loan amount exceeds reviewer authority")
	}
	l.status = LoanStatusApproved
	l.approvedBy = &reviewerID
	now := time.Now()
	l.approvedAt = &now
	l.recordEvent(LoanApprovedEvent{LoanID: l.id, ReviewerID: reviewerID})
	return nil
}

// Reject rejects the loan with a reason
func (l *Loan) Reject(reviewerID ReviewerID, reason string) error {
	if l.status != LoanStatusPendingReview {
		return errors.New("only pending review loans can be rejected")
	}
	if reason == "" {
		return errors.New("rejection reason must be provided")
	}
	l.status = LoanStatusRejected
	l.recordEvent(LoanRejectedEvent{LoanID: l.id, ReviewerID: reviewerID, Reason: reason})
	return nil
}

// recordEvent adds a domain event to the queue
func (l *Loan) recordEvent(event DomainEvent) {
	l.events = append(l.events, event)
}

// PullEvents takes and clears the domain event queue
func (l *Loan) PullEvents() []DomainEvent {
	events := l.events
	l.events = nil
	return events
}

// Getter methods
func (l *Loan) ID() LoanID         { return l.id }
func (l *Loan) Status() LoanStatus { return l.status }
func (l *Loan) Amount() Money      { return l.amount }

// Money is a Value Object — no ID, compared by value
type Money struct {
	amount   int64  // in the smallest unit (cents)
	currency string
}

func NewMoney(amount int64, currency string) (Money, error) {
	if currency == "" {
		return Money{}, errors.New("currency must not be empty")
	}
	return Money{amount: amount, currency: currency}, nil
}

func (m Money) Amount() int64    { return m.amount }
func (m Money) Currency() string { return m.currency }

// Operations produce a new Money — immutable
func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, errors.New("cannot add different currencies")
	}
	return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}

func (m Money) IsZeroOrNegative() bool { return m.amount <= 0 }
func (m Money) GreaterThan(other Money) bool {
	return m.currency == other.currency && m.amount > other.amount
}
func (m Money) Equals(other Money) bool {
	return m.amount == other.amount && m.currency == other.currency
}

// LoanTerm is a Value Object for the loan term
type LoanTerm struct {
	months int
}

func NewLoanTerm(months int) (LoanTerm, error) {
	validTerms := map[int]bool{3: true, 6: true, 12: true, 24: true, 36: true}
	if !validTerms[months] {
		return LoanTerm{}, errors.New("term can only be 3, 6, 12, 24, or 36 months")
	}
	return LoanTerm{months: months}, nil
}

func (t LoanTerm) Months() int  { return t.months }
func (t LoanTerm) IsValid() bool { return t.months > 0 }

// Order is the Aggregate Root controlling OrderItem
type Order struct {
	id         OrderID
	customerID CustomerID
	items      []OrderItem // OrderItem can only be accessed through Order
	status     OrderStatus
	coupon     *Coupon    // optional Value Object
	events     []DomainEvent
}

// OrderItem is an entity inside the aggregate, but has no repository of its own
type OrderItem struct {
	productID ProductID
	quantity  int
	unitPrice Money
}

// AddItem can only be called through Order (the Aggregate Root)
// ✓ This preserves the invariant: total items must not exceed 50
func (o *Order) AddItem(productID ProductID, quantity int, unitPrice Money) error {
	if o.status != OrderStatusDraft {
		return errors.New("items can only be added to a draft order")
	}
	if len(o.items) >= 50 {
		return errors.New("order must not have more than 50 items")
	}
	if quantity <= 0 {
		return errors.New("quantity must be greater than 0")
	}

	// Check if the product already exists, add to its quantity
	for i, item := range o.items {
		if item.productID == productID {
			o.items[i].quantity += quantity
			return nil
		}
	}

	o.items = append(o.items, OrderItem{
		productID: productID,
		quantity:  quantity,
		unitPrice: unitPrice,
	})
	return nil
}

// Total is calculated from the existing items — business logic lives in the entity
func (o *Order) Total() Money {
	total := Money{currency: "IDR"}
	for _, item := range o.items {
		total.amount += item.unitPrice.amount * int64(item.quantity)
	}
	if o.coupon != nil {
		total = o.coupon.Apply(total)
	}
	return total
}

// LoanEligibilityService is a Domain Service
// This logic involves the Applicant and credit history — it does not fit in one entity
type LoanEligibilityService struct{}

func (s *LoanEligibilityService) CheckEligibility(
	applicant *Applicant,
	creditHistory *CreditHistory,
	requestedAmount Money,
) (*EligibilityResult, error) {
	// Business rules involving many domain concepts
	if applicant.Age() < 21 {
		return &EligibilityResult{Eligible: false, Reason: "minimum age is 21"}, nil
	}
	if creditHistory.HasDefaultInLast2Years() {
		return &EligibilityResult{Eligible: false, Reason: "has defaulted credit history"}, nil
	}
	maxLoanable := creditHistory.MaxLoanableAmount()
	if requestedAmount.GreaterThan(maxLoanable) {
		return &EligibilityResult{
			Eligible: false,
			Reason:   fmt.Sprintf("amount exceeds the limit of %s", maxLoanable),
		}, nil
	}
	return &EligibilityResult{Eligible: true}, nil
}

// DomainEvent is the interface for all domain events
type DomainEvent interface {
	EventName() string
	OccurredAt() time.Time
}

// LoanApprovedEvent occurs when a loan is approved
type LoanApprovedEvent struct {
	LoanID     LoanID
	ReviewerID ReviewerID
	occurredAt time.Time
}

func (e LoanApprovedEvent) EventName() string    { return "loan.approved" }
func (e LoanApprovedEvent) OccurredAt() time.Time { return e.occurredAt }

// LoanRejectedEvent occurs when a loan is rejected
type LoanRejectedEvent struct {
	LoanID     LoanID
	ReviewerID ReviewerID
	Reason     string
	occurredAt time.Time
}

func (e LoanRejectedEvent) EventName() string    { return "loan.rejected" }
func (e LoanRejectedEvent) OccurredAt() time.Time { return e.occurredAt }

// In the Lending context: Loan is a rich aggregate with business rules
type Loan struct { // domain/lending/loan.go
    id         LoanID
    applicant  *Applicant
    creditScore CreditScore
    repayment  *RepaymentSchedule
    // ... many business rules
}

// In the Reporting context: LoanSummary is a lightweight read model
type LoanSummary struct { // domain/reporting/loan_summary.go
    LoanID      string
    Amount      float64
    Status      string
    ApprovedAt  *time.Time
    // only the data needed for reports
}

// In the Notification context: LoanNotification is a model for messages
type LoanNotification struct { // domain/notification/loan_notification.go
    RecipientEmail string
    Subject        string
    Body           string
}

// ✗ ANTI-PATTERN: Anemic Domain Model — entity is only data, logic in services
type Loan struct { // just a data container
    ID     string
    Status string
    Amount float64
}

type LoanService struct { // all logic here — the domain becomes a "database record"
    repo LoanRepository
}

func (s *LoanService) ApproveLoan(loanID, reviewerID string) error {
    loan, _ := s.repo.FindByID(loanID)
    if loan.Status != "pending_review" { // ✗ business rules in the service, not the entity
        return errors.New("invalid status")
    }
    loan.Status = "approved"             // ✗ direct mutation from outside
    loan.ReviewerID = reviewerID
    return s.repo.Update(loan)
}

// ✓ CORRECT: Rich Domain Model — business logic lives inside the entity
type Loan struct {
    id         LoanID
    status     LoanStatus
    amount     Money
    approvedBy *ReviewerID
}

// Approve is an entity method containing business rules
func (l *Loan) Approve(reviewerID ReviewerID, maxAuthority Money) error {
    if l.status != LoanStatusPendingReview {  // ✓ business rules inside the entity
        return ErrLoanNotPendingReview
    }
    if l.amount.GreaterThan(maxAuthority) {   // ✓ business validation inside the entity
        return ErrExceedsReviewerAuthority
    }
    l.status = LoanStatusApproved
    l.approvedBy = &reviewerID
    l.recordEvent(LoanApprovedEvent{LoanID: l.id})
    return nil
}

// The Application Service only orchestrates — it contains no business logic
type ApproveLoanService struct {
    loanRepo     LoanRepository
    reviewerRepo ReviewerRepository
    eventBus     EventBus
}

func (s *ApproveLoanService) Execute(ctx context.Context, loanID, reviewerID string) error {
    loan, err := s.loanRepo.FindByID(ctx, LoanID(loanID))
    if err != nil { return err }

    reviewer, err := s.reviewerRepo.FindByID(ctx, ReviewerID(reviewerID))
    if err != nil { return err }

    // Delegate to the entity — the service contains no business logic
    if err := loan.Approve(reviewer.ID(), reviewer.MaxAuthority()); err != nil {
        return err
    }

    if err := s.loanRepo.Save(ctx, loan); err != nil { return err }

    // Publish the domain events
    for _, event := range loan.PullEvents() {
        s.eventBus.Publish(ctx, event)
    }
    return nil
}