Domain-Driven Architecture #

// ✗ ANTI-PATTERN: bahasa teknikal yang tidak merepresentasikan 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)
}

// ✓ BENAR: Ubiquitous Language — kode berbicara bahasa bisnis
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 adalah entity dengan identitas unik
type Loan struct {
	id          LoanID
	applicantID ApplicantID
	amount      Money
	status      LoanStatus
	term        LoanTerm
	appliedAt   time.Time
	approvedBy  *ReviewerID
	approvedAt  *time.Time
	events      []DomainEvent
}

// LoanID adalah strongly-typed ID — mencegah bug akibat string yang salah dipakai
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 adalah factory function yang menegakkan invariant pembuatan
func NewLoan(applicantID ApplicantID, amount Money, term LoanTerm) (*Loan, error) {
	if amount.IsZeroOrNegative() {
		return nil, errors.New("jumlah pinjaman harus lebih dari nol")
	}
	if !term.IsValid() {
		return nil, errors.New("tenor pinjaman tidak valid")
	}

	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 mengajukan pinjaman untuk di-review — menegakkan state machine bisnis
func (l *Loan) Submit() error {
	if l.status != LoanStatusDraft {
		return errors.New("hanya pinjaman draft yang bisa diajukan")
	}
	l.status = LoanStatusPendingReview
	l.recordEvent(LoanSubmittedEvent{LoanID: l.id})
	return nil
}

// Approve menyetujui pinjaman — mengandung aturan bisnis persetujuan
func (l *Loan) ApproveBy(reviewerID ReviewerID, maxAuthority Money) error {
	if l.status != LoanStatusPendingReview {
		return errors.New("hanya pinjaman pending review yang bisa disetujui")
	}
	if l.amount.GreaterThan(maxAuthority) {
		return errors.New("jumlah pinjaman melebihi wewenang reviewer")
	}
	l.status = LoanStatusApproved
	l.approvedBy = &reviewerID
	now := time.Now()
	l.approvedAt = &now
	l.recordEvent(LoanApprovedEvent{LoanID: l.id, ReviewerID: reviewerID})
	return nil
}

// Reject menolak pinjaman dengan alasan
func (l *Loan) Reject(reviewerID ReviewerID, reason string) error {
	if l.status != LoanStatusPendingReview {
		return errors.New("hanya pinjaman pending review yang bisa ditolak")
	}
	if reason == "" {
		return errors.New("alasan penolakan harus diisi")
	}
	l.status = LoanStatusRejected
	l.recordEvent(LoanRejectedEvent{LoanID: l.id, ReviewerID: reviewerID, Reason: reason})
	return nil
}

// recordEvent menambahkan domain event ke antrian
func (l *Loan) recordEvent(event DomainEvent) {
	l.events = append(l.events, event)
}

// PullEvents mengambil dan mengosongkan antrian domain events
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 adalah Value Object — tidak punya ID, dibandingkan berdasarkan nilai
type Money struct {
	amount   int64  // dalam satuan terkecil (sen)
	currency string
}

func NewMoney(amount int64, currency string) (Money, error) {
	if currency == "" {
		return Money{}, errors.New("currency tidak boleh kosong")
	}
	return Money{amount: amount, currency: currency}, nil
}

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

// Operasi menghasilkan Money baru — immutable
func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, errors.New("tidak bisa menjumlahkan mata uang berbeda")
	}
	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 adalah Value Object untuk tenor pinjaman
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("tenor hanya boleh 3, 6, 12, 24, atau 36 bulan")
	}
	return LoanTerm{months: months}, nil
}

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

// Order adalah Aggregate Root yang mengontrol OrderItem
type Order struct {
	id         OrderID
	customerID CustomerID
	items      []OrderItem // OrderItem hanya bisa diakses lewat Order
	status     OrderStatus
	coupon     *Coupon    // Value Object opsional
	events     []DomainEvent
}

// OrderItem adalah entity di dalam aggregate, tapi tidak punya repository sendiri
type OrderItem struct {
	productID ProductID
	quantity  int
	unitPrice Money
}

// AddItem hanya bisa dipanggil lewat Order (Aggregate Root)
// ✓ Ini menjaga invariant: total item tidak boleh lebih dari 50
func (o *Order) AddItem(productID ProductID, quantity int, unitPrice Money) error {
	if o.status != OrderStatusDraft {
		return errors.New("item hanya bisa ditambahkan ke order draft")
	}
	if len(o.items) >= 50 {
		return errors.New("order tidak boleh memiliki lebih dari 50 item")
	}
	if quantity <= 0 {
		return errors.New("quantity harus lebih dari 0")
	}

	// Cek jika produk sudah ada, tambahkan quantity-nya
	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 dihitung dari item-item yang ada — logika bisnis ada di 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 adalah Domain Service
// Logika ini melibatkan Applicant dan credit history — tidak cocok di satu entity
type LoanEligibilityService struct{}

func (s *LoanEligibilityService) CheckEligibility(
	applicant *Applicant,
	creditHistory *CreditHistory,
	requestedAmount Money,
) (*EligibilityResult, error) {
	// Aturan bisnis yang melibatkan banyak konsep domain
	if applicant.Age() < 21 {
		return &EligibilityResult{Eligible: false, Reason: "usia minimum 21 tahun"}, nil
	}
	if creditHistory.HasDefaultInLast2Years() {
		return &EligibilityResult{Eligible: false, Reason: "ada riwayat kredit macet"}, nil
	}
	maxLoanable := creditHistory.MaxLoanableAmount()
	if requestedAmount.GreaterThan(maxLoanable) {
		return &EligibilityResult{
			Eligible: false,
			Reason:   fmt.Sprintf("jumlah melebihi batas %s", maxLoanable),
		}, nil
	}
	return &EligibilityResult{Eligible: true}, nil
}

// DomainEvent adalah interface untuk semua domain event
type DomainEvent interface {
	EventName() string
	OccurredAt() time.Time
}

// LoanApprovedEvent terjadi ketika pinjaman disetujui
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 terjadi ketika pinjaman ditolak
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 }

// Di Lending context: Loan adalah aggregate kaya dengan business rules
type Loan struct { // domain/lending/loan.go
    id         LoanID
    applicant  *Applicant
    creditScore CreditScore
    repayment  *RepaymentSchedule
    // ... banyak aturan bisnis
}

// Di Reporting context: LoanSummary adalah read model yang ringan
type LoanSummary struct { // domain/reporting/loan_summary.go
    LoanID      string
    Amount      float64
    Status      string
    ApprovedAt  *time.Time
    // hanya data yang dibutuhkan untuk laporan
}

// Di Notification context: LoanNotification adalah model untuk pesan
type LoanNotification struct { // domain/notification/loan_notification.go
    RecipientEmail string
    Subject        string
    Body           string
}

// ✗ ANTI-PATTERN: Anemic Domain Model — entity hanya data, logika di service
type Loan struct { // hanya data container
    ID     string
    Status string
    Amount float64
}

type LoanService struct { // semua logika di sini — domain jadi "database record"
    repo LoanRepository
}

func (s *LoanService) ApproveLoan(loanID, reviewerID string) error {
    loan, _ := s.repo.FindByID(loanID)
    if loan.Status != "pending_review" { // ✗ aturan bisnis di service, bukan entity
        return errors.New("invalid status")
    }
    loan.Status = "approved"             // ✗ mutasi langsung dari luar
    loan.ReviewerID = reviewerID
    return s.repo.Update(loan)
}

// ✓ BENAR: Rich Domain Model — logika bisnis ada di dalam entity
type Loan struct {
    id         LoanID
    status     LoanStatus
    amount     Money
    approvedBy *ReviewerID
}

// Approve adalah method entity yang mengandung aturan bisnis
func (l *Loan) Approve(reviewerID ReviewerID, maxAuthority Money) error {
    if l.status != LoanStatusPendingReview {  // ✓ aturan bisnis di dalam entity
        return ErrLoanNotPendingReview
    }
    if l.amount.GreaterThan(maxAuthority) {   // ✓ validasi bisnis di dalam entity
        return ErrExceedsReviewerAuthority
    }
    l.status = LoanStatusApproved
    l.approvedBy = &reviewerID
    l.recordEvent(LoanApprovedEvent{LoanID: l.id})
    return nil
}

// Application Service hanya mengorkestrasikan — tidak mengandung logika bisnis
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 }

    // Delegasikan ke entity — service tidak mengandung logika bisnis
    if err := loan.Approve(reviewer.ID(), reviewer.MaxAuthority()); err != nil {
        return err
    }

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

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