Lapisan & arah ketergantungan

Go dirancang untuk basis kode besar yang dikerjakan banyak orang selama bertahun-tahun. Materi ini tentang menyusun aplikasi web supaya sifat itu benar-benar terasa: setiap potongan punya tempat, dan panah ketergantungannya cuma menunjuk satu arah.

Arah panah

   cmd/server/main.go         ← merakit semuanya (composition root)
          │
          ▼
   internal/http              ← transport: parse, validasi bentuk, tulis respons
          │      tahu tentang domain
          ▼
   internal/produk            ← DOMAIN: tipe, aturan, interface penyimpanan
          ▲      TIDAK tahu tentang HTTP maupun SQL
          │
   internal/produk/postgres   ← infrastruktur: memenuhi interface domain

Per fitur, bukan per jenis

Susunan per jenis membuat satu perubahan fitur menyentuh empat folder yang berjauhan, dan membuat semua paket saling mengimpor sampai batasnya tidak berarti apa-apa. Susunan per fitur menaruh semua yang berubah bersamaan di tempat yang sama — dan membuat "hapus fitur ini" berarti "hapus folder ini".

internal/produk/
├── produk.go       # tipe domain + aturan + error sentinel
├── layanan.go      # orkestrasi: cache, transaksi, kebijakan
├── penyimpan.go    # INTERFACE yang dibutuhkan layanan
├── postgres.go     # implementasi interface itu
└── layanan_test.go

Isi tiap lapisan

Domain — apa yang benar, terlepas dari teknologi

// internal/produk/produk.go
package produk

type Produk struct {
	ID    int64
	Nama  string
	Harga Rupiah
	Stok  int
}

var (
	ErrTidakDitemukan = errors.New("produk tidak ditemukan")
	ErrStokKurang     = errors.New("stok tidak cukup")
)

// Aturan bisnis tinggal di tipe domainnya sendiri — bukan di handler,
// bukan di SQL. Ini yang bisa diuji tanpa satu pun dependensi.
func (p *Produk) Ambil(jumlah int) error {
	switch {
	case jumlah <= 0:
		return fmt.Errorf("jumlah harus positif: %w", ErrValidasi)
	case jumlah > p.Stok:
		return fmt.Errorf("sisa %d: %w", p.Stok, ErrStokKurang)
	}
	p.Stok -= jumlah
	return nil
}

Interface: dideklarasikan oleh yang memakai

// internal/produk/penyimpan.go
package produk

// Hanya method yang BENAR-BENAR dipakai layanan ini. Bukan cerminan
// seluruh API repository.
type Penyimpan interface {
	Ambil(ctx context.Context, id int64) (Produk, error)
	Simpan(ctx context.Context, p Produk) error
	DalamTx(ctx context.Context, f func(Penyimpan) error) error
}

Layanan: merangkai, tapi tidak tahu HTTP

// internal/produk/layanan.go
type Layanan struct {
	simpan Penyimpan
	cache  Cache
	log    *slog.Logger
}

func NewLayanan(s Penyimpan, c Cache, log *slog.Logger) *Layanan {
	return &Layanan{simpan: s, cache: c, log: log}
}

func (l *Layanan) Beli(ctx context.Context, id int64, jumlah int) error {
	return l.simpan.DalamTx(ctx, func(s Penyimpan) error {
		p, err := s.Ambil(ctx, id)
		if err != nil {
			return err
		}
		if err := p.Ambil(jumlah); err != nil {   // aturan domain
			return err
		}
		return s.Simpan(ctx, p)
	})
}

Transport: hanya menerjemahkan

// internal/http/produk.go
func (h *Handler) Beli(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		h.tulisError(w, r, ErrIDTidakValid)
		return
	}

	var req beliReq
	if err := h.bacaJSON(w, r, &req); err != nil {
		h.tulisError(w, r, err)
		return
	}

	if err := h.produk.Beli(r.Context(), id, req.Jumlah); err != nil {
		h.tulisError(w, r, err)     // errors.Is memetakan ke status (Fase 1)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

Berapa lapisan yang benar-benar perlu

Yang menandakan lapisannya sudah bocor

Menegakkannya

# Cek cepat: apa yang diimpor paket domain?
go list -deps ./internal/produk | grep -E 'net/http|database/sql'
# hasil yang benar: kosong

Untuk aturan yang lebih kaya, golangci-lint punya linter depguard yang bisa melarang impor tertentu per paket — dan kegagalannya muncul di CI, bukan di review. Dibahas di Fase 8.