Clean Architecture #

// Entity: Order — aturan bisnis yang berlaku di semua konteks
package domain

import (
	"errors"
	"time"
)

type OrderStatus string

const (
	StatusPending   OrderStatus = "pending"
	StatusConfirmed OrderStatus = "confirmed"
	StatusShipped   OrderStatus = "shipped"
	StatusCancelled OrderStatus = "cancelled"
)

// Order adalah entity yang mengenkapsulasi aturan bisnis order
// Tidak ada import dari database, HTTP, atau framework apapun
type Order struct {
	id         string
	customerID string
	items      []OrderItem
	status     OrderStatus
	total      Money
	createdAt  time.Time
}

type OrderItem struct {
	productID string
	quantity  int
	price     Money
}

// NewOrder adalah factory function yang menegakkan aturan bisnis
func NewOrder(customerID string, items []OrderItem) (*Order, error) {
	if customerID == "" {
		return nil, errors.New("customer ID tidak boleh kosong")
	}
	if len(items) == 0 {
		return nil, errors.New("order harus memiliki minimal satu item")
	}

	total := Money{Amount: 0, Currency: "IDR"}
	for _, item := range items {
		if item.quantity <= 0 {
			return nil, errors.New("quantity harus lebih dari 0")
		}
		total.Amount += item.price.Amount * int64(item.quantity)
	}

	return &Order{
		id:         generateID(),
		customerID: customerID,
		items:      items,
		status:     StatusPending,
		total:      total,
		createdAt:  time.Now(),
	}, nil
}

// Confirm mengubah status order — menegakkan invariant bisnis
func (o *Order) Confirm() error {
	if o.status != StatusPending {
		return errors.New("hanya order pending yang bisa dikonfirmasi")
	}
	o.status = StatusConfirmed
	return nil
}

// Cancel membatalkan order dengan aturan bisnis yang ketat
func (o *Order) Cancel() error {
	if o.status == StatusShipped || o.status == StatusCancelled {
		return errors.New("order yang sudah dikirim atau dibatalkan tidak bisa dibatalkan")
	}
	o.status = StatusCancelled
	return nil
}

// Getter — entity mengontrol akses ke state internalnya
func (o *Order) ID() string          { return o.id }
func (o *Order) CustomerID() string  { return o.customerID }
func (o *Order) Status() OrderStatus { return o.status }
func (o *Order) Total() Money        { return o.total }
func (o *Order) Items() []OrderItem  { return append([]OrderItem{}, o.items...) }

// Use Case: PlaceOrder — alur bisnis spesifik aplikasi ini
package usecase

import (
	"context"
	"time"

	"myapp/domain"
)

// OrderRepository adalah interface yang didefinisikan oleh Use Case
// Implementasinya ada di layer luar (Infrastructure)
// ✓ BENAR: Use Case mendefinisikan kebutuhannya, bukan infrastructure
type OrderRepository interface {
	Save(ctx context.Context, order *domain.Order) error
	FindByID(ctx context.Context, id string) (*domain.Order, error)
	FindByCustomer(ctx context.Context, customerID string) ([]*domain.Order, error)
}

// InventoryService adalah interface untuk mengecek stok
type InventoryService interface {
	CheckAndReserve(ctx context.Context, items []domain.OrderItem) error
}

// NotificationService adalah interface untuk mengirim notifikasi
type NotificationService interface {
	NotifyOrderPlaced(ctx context.Context, order *domain.Order) error
}

// PlaceOrderInput adalah input DTO untuk use case ini
type PlaceOrderInput struct {
	CustomerID string
	Items      []PlaceOrderItem
}

type PlaceOrderItem struct {
	ProductID string
	Quantity  int
	Price     domain.Money
}

// PlaceOrderOutput adalah output DTO
type PlaceOrderOutput struct {
	OrderID   string
	Total     domain.Money
	Status    string
	CreatedAt time.Time
}

// PlaceOrderUseCase mengimplementasikan logika "pelanggan melakukan pemesanan"
type PlaceOrderUseCase struct {
	orderRepo    OrderRepository
	inventory    InventoryService
	notification NotificationService
}

func NewPlaceOrderUseCase(
	orderRepo OrderRepository,
	inventory InventoryService,
	notification NotificationService,
) *PlaceOrderUseCase {
	return &PlaceOrderUseCase{
		orderRepo:    orderRepo,
		inventory:    inventory,
		notification: notification,
	}
}

// Execute menjalankan use case — tidak tahu tentang HTTP, database, atau framework
func (uc *PlaceOrderUseCase) Execute(ctx context.Context, input PlaceOrderInput) (*PlaceOrderOutput, error) {
	// Konversi input ke domain object
	items := make([]domain.OrderItem, len(input.Items))
	for i, item := range input.Items {
		items[i] = domain.OrderItem{
			ProductID: item.ProductID,
			Quantity:  item.Quantity,
			Price:     item.Price,
		}
	}

	// Buat entity Order — validasi bisnis ada di dalam entity
	order, err := domain.NewOrder(input.CustomerID, items)
	if err != nil {
		return nil, err
	}

	// Cek dan reservasi stok melalui interface
	if err := uc.inventory.CheckAndReserve(ctx, items); err != nil {
		return nil, err
	}

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

	// Kirim notifikasi — jika gagal, log saja, jangan gagalkan order
	_ = uc.notification.NotifyOrderPlaced(ctx, order)

	return &PlaceOrderOutput{
		OrderID:   order.ID(),
		Total:     order.Total(),
		Status:    string(order.Status()),
		CreatedAt: time.Now(),
	}, nil
}

// Controller: HTTP handler yang menerjemahkan HTTP request ke Use Case
package http

import (
	"encoding/json"
	"net/http"

	"myapp/domain"
	"myapp/usecase"
)

// PlaceOrderRequest adalah struktur JSON yang diterima dari client
// ✓ Model transport dipisah dari domain entity
type PlaceOrderRequest struct {
	CustomerID string              `json:"customer_id"`
	Items      []PlaceOrderItemReq `json:"items"`
}

type PlaceOrderItemReq struct {
	ProductID string `json:"product_id"`
	Quantity  int    `json:"quantity"`
	Price     int64  `json:"price"`
}

// PlaceOrderResponse adalah struktur JSON yang dikirim ke client
type PlaceOrderResponse struct {
	OrderID string `json:"order_id"`
	Total   int64  `json:"total"`
	Status  string `json:"status"`
}

// OrderController bertanggung jawab hanya untuk:
// 1. Parse dan validasi request
// 2. Map ke Use Case input
// 3. Panggil Use Case
// 4. Map output ke response
// TIDAK ada business logic di sini
type OrderController struct {
	placeOrderUC *usecase.PlaceOrderUseCase
}

func NewOrderController(placeOrderUC *usecase.PlaceOrderUseCase) *OrderController {
	return &OrderController{placeOrderUC: placeOrderUC}
}

func (c *OrderController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
	var req PlaceOrderRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "request tidak valid", http.StatusBadRequest)
		return
	}

	// Map HTTP request → Use Case input
	items := make([]usecase.PlaceOrderItem, len(req.Items))
	for i, item := range req.Items {
		items[i] = usecase.PlaceOrderItem{
			ProductID: item.ProductID,
			Quantity:  item.Quantity,
			Price:     domain.Money{Amount: item.Price, Currency: "IDR"},
		}
	}

	// Panggil Use Case — controller tidak tahu implementasi di baliknya
	output, err := c.placeOrderUC.Execute(r.Context(), usecase.PlaceOrderInput{
		CustomerID: req.CustomerID,
		Items:      items,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusUnprocessableEntity)
		return
	}

	// Map Use Case output → HTTP response
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(PlaceOrderResponse{
		OrderID: output.OrderID,
		Total:   output.Total.Amount,
		Status:  output.Status,
	})
}

// Repository: implementasi konkret yang mengakses database
package postgres

import (
	"context"
	"database/sql"

	"myapp/domain"
)

// PostgresOrderRepository mengimplementasikan usecase.OrderRepository
// ✓ Interface didefinisikan di Use Case, implementasi ada di sini
type PostgresOrderRepository struct {
	db *sql.DB
}

func NewPostgresOrderRepository(db *sql.DB) *PostgresOrderRepository {
	return &PostgresOrderRepository{db: db}
}

func (r *PostgresOrderRepository) Save(ctx context.Context, order *domain.Order) error {
	_, err := r.db.ExecContext(ctx,
		`INSERT INTO orders (id, customer_id, status, total_amount, created_at)
		 VALUES ($1, $2, $3, $4, $5)`,
		order.ID(), order.CustomerID(), order.Status(), order.Total().Amount, time.Now(),
	)
	return err
}

// cmd/server/main.go — satu-satunya tempat yang "tahu segalanya"
package main

import (
	"database/sql"
	"log"
	"net/http"

	_ "github.com/lib/pq"

	adapterhttp "myapp/adapter/http"
	"myapp/infrastructure/kafka"
	"myapp/infrastructure/postgres"
	"myapp/usecase"
)

func main() {
	// Inisialisasi infrastruktur
	db, err := sql.Open("postgres", "postgres://localhost/myapp?sslmode=disable")
	if err != nil {
		log.Fatal("gagal koneksi database:", err)
	}
	defer db.Close()

	// Buat implementasi konkret (infrastructure layer)
	orderRepo := postgres.NewPostgresOrderRepository(db)
	inventorySvc := inventory.NewInventoryClient("http://inventory-service")
	notificationSvc := kafka.NewKafkaNotificationProducer("localhost:9092")

	// Buat use case dengan dependency injection
	// ✓ Use case hanya menerima interface — tidak tahu implementasi konkret
	placeOrderUC := usecase.NewPlaceOrderUseCase(orderRepo, inventorySvc, notificationSvc)

	// Buat controller (adapter layer)
	orderController := adapterhttp.NewOrderController(placeOrderUC)

	// Setup router (framework layer)
	mux := http.NewServeMux()
	mux.HandleFunc("POST /orders", orderController.PlaceOrder)

	log.Println("Server berjalan di :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

// usecase/place_order_test.go
package usecase_test

import (
	"context"
	"testing"

	"myapp/domain"
	"myapp/usecase"
)

// Mock repository — tidak perlu database nyata
type mockOrderRepository struct {
	savedOrders []*domain.Order
}

func (m *mockOrderRepository) Save(ctx context.Context, order *domain.Order) error {
	m.savedOrders = append(m.savedOrders, order)
	return nil
}

func (m *mockOrderRepository) FindByID(ctx context.Context, id string) (*domain.Order, error) {
	return nil, nil
}

func (m *mockOrderRepository) FindByCustomer(ctx context.Context, customerID string) ([]*domain.Order, error) {
	return nil, nil
}

// Mock inventory service — tidak perlu HTTP call ke inventory service
type mockInventoryService struct {
	shouldFail bool
}

func (m *mockInventoryService) CheckAndReserve(ctx context.Context, items []domain.OrderItem) error {
	if m.shouldFail {
		return errors.New("stok tidak cukup")
	}
	return nil
}

// Mock notification service
type mockNotificationService struct{}

func (m *mockNotificationService) NotifyOrderPlaced(ctx context.Context, order *domain.Order) error {
	return nil
}

// Test use case tanpa database, tanpa HTTP, tanpa Kafka
func TestPlaceOrder_Success(t *testing.T) {
	repo := &mockOrderRepository{}
	inventory := &mockInventoryService{}
	notification := &mockNotificationService{}

	uc := usecase.NewPlaceOrderUseCase(repo, inventory, notification)

	output, err := uc.Execute(context.Background(), usecase.PlaceOrderInput{
		CustomerID: "customer-123",
		Items: []usecase.PlaceOrderItem{
			{ProductID: "prod-1", Quantity: 2, Price: domain.Money{Amount: 50000, Currency: "IDR"}},
		},
	})

	if err != nil {
		t.Fatalf("expected no error, got: %v", err)
	}
	if output.OrderID == "" {
		t.Error("expected order ID, got empty string")
	}
	if output.Total.Amount != 100000 {
		t.Errorf("expected total 100000, got %d", output.Total.Amount)
	}
	if len(repo.savedOrders) != 1 {
		t.Errorf("expected 1 saved order, got %d", len(repo.savedOrders))
	}
}

func TestPlaceOrder_InsufficientStock(t *testing.T) {
	repo := &mockOrderRepository{}
	inventory := &mockInventoryService{shouldFail: true} // simulasi stok habis
	notification := &mockNotificationService{}

	uc := usecase.NewPlaceOrderUseCase(repo, inventory, notification)

	_, err := uc.Execute(context.Background(), usecase.PlaceOrderInput{
		CustomerID: "customer-123",
		Items: []usecase.PlaceOrderItem{
			{ProductID: "prod-1", Quantity: 999, Price: domain.Money{Amount: 50000, Currency: "IDR"}},
		},
	})

	if err == nil {
		t.Error("expected error for insufficient stock, got nil")
	}
	if len(repo.savedOrders) != 0 {
		t.Error("order tidak boleh disimpan jika stok tidak cukup")
	}
}

// ✗ Import database di domain entity — pelanggaran Dependency Rule
package domain

import "database/sql" // ✗ domain tidak boleh tahu tentang SQL

type Order struct {
    db *sql.DB // ✗ entity menyimpan referensi ke database
}

// ✓ Domain entity murni — tidak ada import infrastruktur
package domain

type Order struct {
    id     string
    status OrderStatus
    // tidak ada database, tidak ada HTTP, tidak ada framework
}

// ✗ Business logic di controller
func (c *OrderController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
    // ✗ validasi bisnis yang seharusnya di domain
    if order.Total > 10000000 {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    // ✗ manipulasi state domain langsung dari controller
    order.Status = "confirmed"
}

// ✓ Controller hanya parse, delegate ke use case, format response
func (c *OrderController) PlaceOrder(w http.ResponseWriter, r *http.Request) {
    var req PlaceOrderRequest
    json.NewDecoder(r.Body).Decode(&req)
    output, err := c.placeOrderUC.Execute(r.Context(), mapToInput(req)) // ✓ delegate
    if err != nil {
        http.Error(w, err.Error(), http.StatusUnprocessableEntity)
        return
    }
    json.NewEncoder(w).Encode(mapToResponse(output))
}

// ✗ Memakai struct database langsung sebagai entity
type OrderRow struct {  // ✗ ini adalah database model, bukan domain entity
    ID         int64  `db:"id"`
    CustomerID string `db:"customer_id"`
    Status     string `db:"status"`
}

// ✓ Pisahkan database model dari domain entity
type Order struct { // domain entity — tidak ada tag db
    id         string
    customerID string
    status     OrderStatus
}

type orderRow struct { // database model — hanya di infrastructure layer
    ID         int64  `db:"id"`
    CustomerID string `db:"customer_id"`
    Status     string `db:"status"`
}

// ✗ Interface yang terlalu besar di use case — melanggar Interface Segregation
type OrderRepository interface {
    Save(...)
    FindByID(...)
    FindByCustomer(...)
    FindByDateRange(...)      // ✗ hanya dipakai satu use case
    CountByStatus(...)        // ✗ hanya dipakai reporting
    GenerateReport(...)       // ✗ ini bukan tanggung jawab repository
}

// ✓ Interface kecil dan spesifik per use case
type OrderSaver interface { // hanya untuk PlaceOrderUseCase
    Save(ctx context.Context, order *domain.Order) error
}

type OrderFinder interface { // hanya untuk GetOrderUseCase
    FindByID(ctx context.Context, id string) (*domain.Order, error)
}