Onion Architecture #

// domain/product.go — Entity
package domain

import (
	"errors"
	"time"
)

type ProductID string
type CategoryID string

// Product adalah entity di domain layer — tidak ada ORM tag, tidak ada JSON tag
type Product struct {
	id          ProductID
	name        string
	description string
	price       Money
	stock       int
	categoryID  CategoryID
	createdAt   time.Time
	updatedAt   time.Time
}

// NewProduct menegakkan invariant bisnis saat pembuatan
func NewProduct(name, description string, price Money, categoryID CategoryID) (*Product, error) {
	if name == "" {
		return nil, errors.New("nama produk tidak boleh kosong")
	}
	if len(name) > 200 {
		return nil, errors.New("nama produk tidak boleh lebih dari 200 karakter")
	}
	if price.IsZeroOrNegative() {
		return nil, errors.New("harga produk harus lebih dari nol")
	}
	return &Product{
		id:          ProductID(generateID()),
		name:        name,
		description: description,
		price:       price,
		stock:       0,
		categoryID:  categoryID,
		createdAt:   time.Now(),
		updatedAt:   time.Now(),
	}, nil
}

// AddStock menambah stok — logika bisnis ada di dalam entity
func (p *Product) AddStock(qty int) error {
	if qty <= 0 {
		return errors.New("jumlah stok yang ditambahkan harus lebih dari 0")
	}
	p.stock += qty
	p.updatedAt = time.Now()
	return nil
}

// Deduct mengurangi stok saat terjadi pembelian
func (p *Product) Deduct(qty int) error {
	if qty <= 0 {
		return errors.New("jumlah yang dikurangi harus lebih dari 0")
	}
	if p.stock < qty {
		return errors.New("stok tidak mencukupi")
	}
	p.stock -= qty
	p.updatedAt = time.Now()
	return nil
}

// UpdatePrice memperbarui harga dengan validasi bisnis
func (p *Product) UpdatePrice(newPrice Money) error {
	if newPrice.IsZeroOrNegative() {
		return errors.New("harga baru harus lebih dari nol")
	}
	p.price = newPrice
	p.updatedAt = time.Now()
	return nil
}

// Getter — entity mengontrol akses ke state internalnya
func (p *Product) ID() ProductID        { return p.id }
func (p *Product) Name() string         { return p.name }
func (p *Product) Description() string  { return p.description }
func (p *Product) Price() Money         { return p.price }
func (p *Product) Stock() int           { return p.stock }
func (p *Product) CategoryID() CategoryID { return p.categoryID }
func (p *Product) CreatedAt() time.Time { return p.createdAt }
func (p *Product) UpdatedAt() time.Time { return p.updatedAt }
func (p *Product) IsAvailable() bool    { return p.stock > 0 }

// domain/money.go — Value Object
package domain

import (
	"errors"
	"fmt"
)

// Money adalah Value Object — immutable, equality by value
type Money struct {
	cents    int64
	currency string
}

func NewMoney(cents int64, currency string) (Money, error) {
	if currency == "" {
		return Money{}, errors.New("currency tidak boleh kosong")
	}
	if cents < 0 {
		return Money{}, errors.New("nilai uang tidak boleh negatif")
	}
	return Money{cents: cents, currency: currency}, nil
}

func (m Money) Cents() int64    { return m.cents }
func (m Money) Currency() string { return m.currency }
func (m Money) IsZeroOrNegative() bool { return m.cents <= 0 }

func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, fmt.Errorf("tidak bisa menjumlahkan %s dengan %s", m.currency, other.currency)
	}
	return Money{cents: m.cents + other.cents, currency: m.currency}, nil
}

func (m Money) Multiply(factor int) Money {
	return Money{cents: m.cents * int64(factor), currency: m.currency}
}

func (m Money) Equals(other Money) bool {
	return m.cents == other.cents && m.currency == other.currency
}

// domain/repository.go — Repository Interface didefinisikan di domain
// ✓ Domain mendefinisikan kebutuhannya — infrastructure memenuhinya
package domain

import "context"

// ProductRepository adalah interface yang didefinisikan oleh domain
// Implementasinya ada di infrastructure layer
type ProductRepository interface {
	Save(ctx context.Context, product *Product) error
	FindByID(ctx context.Context, id ProductID) (*Product, error)
	FindByCategory(ctx context.Context, categoryID CategoryID) ([]*Product, error)
	FindAvailable(ctx context.Context) ([]*Product, error)
	Delete(ctx context.Context, id ProductID) error
}

// domain/inventory_service.go — Domain Service
// Logika yang melibatkan banyak entity dan tidak cocok di satu entity
package domain

import (
	"context"
	"errors"
)

// InventoryService adalah Domain Service untuk operasi stok yang kompleks
type InventoryService struct {
	productRepo ProductRepository
}

func NewInventoryService(productRepo ProductRepository) *InventoryService {
	return &InventoryService{productRepo: productRepo}
}

// TransferStock memindahkan stok dari satu produk ke produk lain
// Logika ini melibatkan dua entity — tidak cocok di salah satu entity
func (s *InventoryService) TransferStock(
	ctx context.Context,
	fromID, toID ProductID,
	quantity int,
) error {
	from, err := s.productRepo.FindByID(ctx, fromID)
	if err != nil {
		return err
	}
	to, err := s.productRepo.FindByID(ctx, toID)
	if err != nil {
		return err
	}

	// Kurangi dari source
	if err := from.Deduct(quantity); err != nil {
		return errors.New("sumber tidak memiliki stok cukup: " + err.Error())
	}

	// Tambahkan ke destination
	if err := to.AddStock(quantity); err != nil {
		return err
	}

	// Simpan keduanya
	if err := s.productRepo.Save(ctx, from); err != nil {
		return err
	}
	return s.productRepo.Save(ctx, to)
}

// application/create_product.go
package application

import (
	"context"

	"myapp/domain"
)

// CreateProductInput adalah input DTO dari luar ke application layer
type CreateProductInput struct {
	Name        string
	Description string
	PriceCents  int64
	Currency    string
	CategoryID  string
}

// CreateProductOutput adalah output DTO dari application layer ke luar
type CreateProductOutput struct {
	ProductID   string
	Name        string
	PriceCents  int64
	Stock       int
}

// CreateProductUseCase mengorkestrasikan pembuatan produk baru
type CreateProductUseCase struct {
	productRepo domain.ProductRepository
}

func NewCreateProductUseCase(productRepo domain.ProductRepository) *CreateProductUseCase {
	return &CreateProductUseCase{productRepo: productRepo}
}

func (uc *CreateProductUseCase) Execute(ctx context.Context, input CreateProductInput) (*CreateProductOutput, error) {
	// Buat value object
	price, err := domain.NewMoney(input.PriceCents, input.Currency)
	if err != nil {
		return nil, err
	}

	// Buat domain entity — validasi ada di dalam entity
	product, err := domain.NewProduct(
		input.Name,
		input.Description,
		price,
		domain.CategoryID(input.CategoryID),
	)
	if err != nil {
		return nil, err
	}

	// Simpan melalui repository interface
	if err := uc.productRepo.Save(ctx, product); err != nil {
		return nil, err
	}

	return &CreateProductOutput{
		ProductID:  string(product.ID()),
		Name:       product.Name(),
		PriceCents: product.Price().Cents(),
		Stock:      product.Stock(),
	}, nil
}

// AddStockInput adalah input untuk menambah stok
type AddStockInput struct {
	ProductID string
	Quantity  int
}

// AddStockUseCase mengorkestrasikan penambahan stok produk
type AddStockUseCase struct {
	productRepo domain.ProductRepository
}

func NewAddStockUseCase(productRepo domain.ProductRepository) *AddStockUseCase {
	return &AddStockUseCase{productRepo: productRepo}
}

func (uc *AddStockUseCase) Execute(ctx context.Context, input AddStockInput) error {
	product, err := uc.productRepo.FindByID(ctx, domain.ProductID(input.ProductID))
	if err != nil {
		return err
	}

	// Delegasikan ke domain entity — use case tidak mengandung logika bisnis
	if err := product.AddStock(input.Quantity); err != nil {
		return err
	}

	return uc.productRepo.Save(ctx, product)
}

// ✗ ANTI-PATTERN: domain entity dicemari ORM annotation
type Product struct {
	ID          int64  `gorm:"primaryKey;autoIncrement"` // ✗ detail ORM di domain
	Name        string `gorm:"column:product_name;not null"`
	PriceCents  int64  `gorm:"column:price_cents"`
	Stock       int    `gorm:"default:0"`
}

// ✗ ANTI-PATTERN: JSON tag di domain entity
type Product struct {
	ID    string `json:"id"` // ✗ transport concern di domain
	Name  string `json:"name"`
}

// ✓ BENAR: domain entity murni — tidak ada tag apapun
type Product struct {
	id    ProductID // field private, tidak ada tag
	name  string
	price Money
	stock int
}

// ✓ BENAR: persistence model terpisah di infrastructure layer
// infrastructure/postgres/model.go
package postgres

import "time"

// productRow adalah model database — hanya ada di infrastructure
type productRow struct {
	ID          string    `db:"id"`
	Name        string    `db:"name"`
	Description string    `db:"description"`
	PriceCents  int64     `db:"price_cents"`
	Currency    string    `db:"currency"`
	Stock       int       `db:"stock"`
	CategoryID  string    `db:"category_id"`
	CreatedAt   time.Time `db:"created_at"`
	UpdatedAt   time.Time `db:"updated_at"`
}

// toDomain mengonversi persistence model ke domain entity
func (r *productRow) toDomain() (*domain.Product, error) {
	price, err := domain.NewMoney(r.PriceCents, r.Currency)
	if err != nil {
		return nil, err
	}
	// Rekonstruksi entity dari data persistence
	return domain.ReconstructProduct(
		domain.ProductID(r.ID),
		r.Name,
		r.Description,
		price,
		r.Stock,
		domain.CategoryID(r.CategoryID),
		r.CreatedAt,
		r.UpdatedAt,
	), nil
}

// infrastructure/postgres/product_repository.go
package postgres

import (
	"context"
	"database/sql"
	"fmt"

	"myapp/domain"
)

// PostgresProductRepository mengimplementasikan domain.ProductRepository
type PostgresProductRepository struct {
	db *sql.DB
}

// Compile-time check — memastikan interface terpenuhi
var _ domain.ProductRepository = (*PostgresProductRepository)(nil)

func NewPostgresProductRepository(db *sql.DB) *PostgresProductRepository {
	return &PostgresProductRepository{db: db}
}

func (r *PostgresProductRepository) Save(ctx context.Context, p *domain.Product) error {
	_, err := r.db.ExecContext(ctx,
		`INSERT INTO products (id, name, description, price_cents, currency, stock, category_id, created_at, updated_at)
		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
		 ON CONFLICT (id) DO UPDATE
		 SET name = $2, description = $3, price_cents = $4,
		     stock = $6, updated_at = $9`,
		string(p.ID()), p.Name(), p.Description(),
		p.Price().Cents(), p.Price().Currency(),
		p.Stock(), string(p.CategoryID()),
		p.CreatedAt(), p.UpdatedAt(),
	)
	if err != nil {
		return fmt.Errorf("gagal menyimpan produk: %w", err)
	}
	return nil
}

func (r *PostgresProductRepository) FindByID(ctx context.Context, id domain.ProductID) (*domain.Product, error) {
	row := &productRow{}
	err := r.db.QueryRowContext(ctx,
		`SELECT id, name, description, price_cents, currency, stock, category_id, created_at, updated_at
		 FROM products WHERE id = $1`,
		string(id),
	).Scan(
		&row.ID, &row.Name, &row.Description, &row.PriceCents, &row.Currency,
		&row.Stock, &row.CategoryID, &row.CreatedAt, &row.UpdatedAt,
	)
	if err == sql.ErrNoRows {
		return nil, fmt.Errorf("produk tidak ditemukan: %s", id)
	}
	if err != nil {
		return nil, fmt.Errorf("gagal membaca produk: %w", err)
	}
	return row.toDomain()
}

// domain/product_test.go — Menguji entity murni, tidak ada dependency apapun
package domain_test

import (
	"testing"
)

func TestProduct_AddStock(t *testing.T) {
	price, _ := NewMoney(100000, "IDR")
	product, err := NewProduct("Laptop", "Gaming laptop", price, "cat-electronics")
	if err != nil {
		t.Fatal(err)
	}

	// Test: tambah stok valid
	if err := product.AddStock(10); err != nil {
		t.Errorf("tidak mengharapkan error: %v", err)
	}
	if product.Stock() != 10 {
		t.Errorf("stok seharusnya 10, dapat %d", product.Stock())
	}

	// Test: tambah stok invalid
	if err := product.AddStock(0); err == nil {
		t.Error("seharusnya error untuk qty = 0")
	}
	if err := product.AddStock(-5); err == nil {
		t.Error("seharusnya error untuk qty negatif")
	}
}

func TestProduct_Deduct_InsufficientStock(t *testing.T) {
	price, _ := NewMoney(100000, "IDR")
	product, _ := NewProduct("Laptop", "desc", price, "cat-1")
	product.AddStock(5)

	if err := product.Deduct(10); err == nil {
		t.Error("seharusnya error saat stok tidak cukup")
	}
	if product.Stock() != 5 {
		t.Errorf("stok tidak boleh berubah saat deduct gagal, dapat %d", product.Stock())
	}
}

// application/create_product_test.go — Menguji use case dengan mock repository
package application_test

import (
	"context"
	"testing"

	"myapp/application"
	"myapp/domain"
)

type mockProductRepo struct {
	products map[string]*domain.Product
}

func newMockProductRepo() *mockProductRepo {
	return &mockProductRepo{products: make(map[string]*domain.Product)}
}

func (m *mockProductRepo) Save(ctx context.Context, p *domain.Product) error {
	m.products[string(p.ID())] = p
	return nil
}

func (m *mockProductRepo) FindByID(ctx context.Context, id domain.ProductID) (*domain.Product, error) {
	if p, ok := m.products[string(id)]; ok {
		return p, nil
	}
	return nil, errors.New("not found")
}

func (m *mockProductRepo) FindByCategory(ctx context.Context, id domain.CategoryID) ([]*domain.Product, error) {
	return nil, nil
}

func (m *mockProductRepo) FindAvailable(ctx context.Context) ([]*domain.Product, error) {
	return nil, nil
}

func (m *mockProductRepo) Delete(ctx context.Context, id domain.ProductID) error {
	delete(m.products, string(id))
	return nil
}

func TestCreateProductUseCase_Success(t *testing.T) {
	repo := newMockProductRepo()
	uc := application.NewCreateProductUseCase(repo) // ✓ tidak butuh PostgreSQL nyata

	output, err := uc.Execute(context.Background(), application.CreateProductInput{
		Name:        "Mechanical Keyboard",
		Description: "TKL layout, red switch",
		PriceCents:  75000000, // 750.000 IDR dalam sen
		Currency:    "IDR",
		CategoryID:  "cat-peripherals",
	})

	if err != nil {
		t.Fatalf("tidak mengharapkan error: %v", err)
	}
	if output.ProductID == "" {
		t.Error("product ID tidak boleh kosong")
	}
	if output.PriceCents != 75000000 {
		t.Errorf("harga seharusnya 75000000, dapat %d", output.PriceCents)
	}
	if len(repo.products) != 1 {
		t.Errorf("seharusnya 1 produk tersimpan, dapat %d", len(repo.products))
	}
}

// ✗ Import infrastructure di domain — pelanggaran paling dasar
package domain

import (
	"gorm.io/gorm"       // ✗ ORM di domain
	"github.com/gin-gonic/gin" // ✗ framework HTTP di domain
)

type Product struct {
	gorm.Model // ✗ embedding model ORM di domain entity
	Name string
}

// ✓ Domain murni — tidak ada import dari library eksternal
package domain

type Product struct {
	id    ProductID
	name  string
	price Money
	stock int
}

// ✗ Business logic di infrastructure (HTTP handler)
func (h *ProductHandler) CreateProduct(c *gin.Context) {
	var req CreateProductReq
	c.ShouldBindJSON(&req)

	// ✗ validasi bisnis di handler
	if req.Stock < 0 {
		c.JSON(400, gin.H{"error": "stok tidak boleh negatif"})
		return
	}
	// ✗ kalkulasi harga di handler
	finalPrice := req.Price * 1.1 // tambah PPN 10%
	// ...
}

// ✓ Handler tipis — delegate ke use case
func (h *ProductHandler) CreateProduct(c *gin.Context) {
	var req CreateProductReq
	c.ShouldBindJSON(&req)
	output, err := h.createProductUC.Execute(c.Request.Context(), mapToInput(req))
	if err != nil {
		c.JSON(422, gin.H{"error": err.Error()})
		return
	}
	c.JSON(201, mapToResponse(output))
}

// ✗ Application use case mengimport infrastructure langsung
package application

import "myapp/infrastructure/postgres" // ✗ dependency ke infrastructure konkret

type CreateProductUseCase struct {
	repo *postgres.PostgresProductRepository // ✗ struct konkret, bukan interface
}

// ✓ Application bergantung pada domain interface, bukan implementation konkret
package application

import "myapp/domain"

type CreateProductUseCase struct {
	repo domain.ProductRepository // ✓ interface — infrastructure bisa diganti
}

// ✗ Satu layer mengandung semua concern — God Layer
package application

type ProductService struct{} // ✗ berisi HTTP parsing, SQL query, dan business logic sekaligus

func (s *ProductService) CreateProduct(r *http.Request) ([]byte, error) {
	// parsing HTTP request (infrastructure concern)
	// validasi bisnis (domain concern)
	// query SQL langsung (infrastructure concern)
	// format JSON response (infrastructure concern)
}

// ✓ Setiap layer punya tanggung jawab yang jelas
// Infrastructure: parse HTTP, format response
// Application: orkestrasi use case
// Domain: business rules dan invariant