SoC — Separation of Concerns #

// ANTI-PATTERN: semua concern dalam satu fungsi
// HTTP, validasi, business logic, database, response — semuanya di sini
func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
    // === Concern 1: HTTP parsing ===
    var req struct {
        UserID string      `json:"user_id"`
        Items  []struct {
            ProductID string `json:"product_id"`
            Quantity  int    `json:"quantity"`
        } `json:"items"`
    }
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid request body", http.StatusBadRequest)
        return
    }

    // === Concern 2: Validasi ===
    if req.UserID == "" {
        http.Error(w, "user_id is required", http.StatusBadRequest)
        return
    }
    if len(req.Items) == 0 {
        http.Error(w, "at least one item required", http.StatusBadRequest)
        return
    }

    // === Concern 3: Cek user (business rule) — langsung query ===
    var userActive bool
    db.QueryRow("SELECT is_active FROM users WHERE id = ?", req.UserID).Scan(&userActive)
    if !userActive {
        http.Error(w, "user account is not active", http.StatusForbidden)
        return
    }

    // === Concern 4: Hitung total (business logic) ===
    total := 0.0
    for _, item := range req.Items {
        var price float64
        db.QueryRow("SELECT price FROM products WHERE id = ?", item.ProductID).Scan(&price)
        total += price * float64(item.Quantity)
    }

    // === Concern 5: Simpan order (data access) ===
    result, err := db.Exec(
        "INSERT INTO orders (user_id, total, status) VALUES (?, ?, 'pending')",
        req.UserID, total,
    )
    if err != nil {
        http.Error(w, "failed to create order", http.StatusInternalServerError)
        return
    }
    orderID, _ := result.LastInsertId()

    // === Concern 6: Format response ===
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "order_id": orderID,
        "total":    total,
        "status":   "pending",
    })
}
// Test untuk fungsi ini membutuhkan: HTTP server + database yang terisi data
// Business logic "hitung total" tidak bisa ditest secara independen
// Logika yang sama tidak bisa dipakai dari background worker

// internal/order/domain.go
package order

import (
    "errors"
    "time"
)

// Order adalah domain entity — tidak tahu HTTP, tidak tahu SQL
type Order struct {
    ID        string
    UserID    string
    Items     []OrderItem
    Status    Status
    CreatedAt time.Time
}

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice float64
}

type Status string

const (
    StatusPending   Status = "pending"
    StatusConfirmed Status = "confirmed"
    StatusCancelled Status = "cancelled"
)

// Business rule melekat pada domain, bukan di handler atau service
func (o Order) Total() float64 {
    total := 0.0
    for _, item := range o.Items {
        total += item.UnitPrice * float64(item.Quantity)
    }
    return total
}

func (o Order) IsEmpty() bool {
    return len(o.Items) == 0
}

func (o Order) Validate() error {
    if o.UserID == "" {
        return errors.New("order must belong to a user")
    }
    if o.IsEmpty() {
        return errors.New("order must have at least one item")
    }
    return nil
}

// Concern: representasi data dan aturan inti domain
// Tidak tahu: cara data disimpan, cara request datang, cara response diformat

// internal/order/repository.go
package order

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

// OrderRepository adalah interface — bergantung pada abstraksi (DIP)
type OrderRepository interface {
    Save(ctx context.Context, order Order) (string, error)
    FindByID(ctx context.Context, id string) (*Order, error)
    FindByUserID(ctx context.Context, userID string) ([]Order, error)
}

type postgresOrderRepository struct {
    db *sql.DB
}

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

func (r *postgresOrderRepository) Save(ctx context.Context, order Order) (string, error) {
    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return "", fmt.Errorf("save order: begin tx: %w", err)
    }
    defer tx.Rollback()

    var orderID string
    err = tx.QueryRowContext(ctx,
        `INSERT INTO orders (user_id, total, status) VALUES ($1, $2, $3) RETURNING id`,
        order.UserID, order.Total(), string(order.Status),
    ).Scan(&orderID)
    if err != nil {
        return "", fmt.Errorf("save order: insert: %w", err)
    }

    for _, item := range order.Items {
        _, err = tx.ExecContext(ctx,
            `INSERT INTO order_items (order_id, product_id, quantity, unit_price)
             VALUES ($1, $2, $3, $4)`,
            orderID, item.ProductID, item.Quantity, item.UnitPrice,
        )
        if err != nil {
            return "", fmt.Errorf("save order: insert item: %w", err)
        }
    }

    if err := tx.Commit(); err != nil {
        return "", fmt.Errorf("save order: commit: %w", err)
    }
    return orderID, nil
}

// Concern: bagaimana data disimpan dan diambil dari database
// Tidak tahu: HTTP, business rules, cara validasi input

// internal/order/service.go
package order

import (
    "context"
    "fmt"
)

type UserChecker interface {
    IsActive(ctx context.Context, userID string) (bool, error)
}

type ProductPricer interface {
    GetPrice(ctx context.Context, productID string) (float64, error)
}

type OrderService struct {
    repo    OrderRepository
    users   UserChecker
    pricing ProductPricer
}

func NewOrderService(
    repo OrderRepository,
    users UserChecker,
    pricing ProductPricer,
) *OrderService {
    return &OrderService{repo: repo, users: users, pricing: pricing}
}

type CreateOrderRequest struct {
    UserID string
    Items  []CreateOrderItem
}

type CreateOrderItem struct {
    ProductID string
    Quantity  int
}

func (s *OrderService) CreateOrder(ctx context.Context, req CreateOrderRequest) (string, error) {
    // Business rule: cek user aktif
    active, err := s.users.IsActive(ctx, req.UserID)
    if err != nil {
        return "", fmt.Errorf("createOrder: check user: %w", err)
    }
    if !active {
        return "", ErrUserNotActive
    }

    // Bangun domain entity dengan harga dari product service
    items := make([]OrderItem, 0, len(req.Items))
    for _, reqItem := range req.Items {
        price, err := s.pricing.GetPrice(ctx, reqItem.ProductID)
        if err != nil {
            return "", fmt.Errorf("createOrder: get price %s: %w", reqItem.ProductID, err)
        }
        items = append(items, OrderItem{
            ProductID: reqItem.ProductID,
            Quantity:  reqItem.Quantity,
            UnitPrice: price,
        })
    }

    order := Order{
        UserID: req.UserID,
        Items:  items,
        Status: StatusPending,
    }

    // Validasi domain entity
    if err := order.Validate(); err != nil {
        return "", fmt.Errorf("createOrder: validate: %w", err)
    }

    // Simpan melalui repository
    orderID, err := s.repo.Save(ctx, order)
    if err != nil {
        return "", fmt.Errorf("createOrder: save: %w", err)
    }

    return orderID, nil
}

// Concern: orchestrasi business logic
// Tidak tahu: HTTP, SQL query, format JSON

// internal/api/order_handler.go
package api

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

    "github.com/example/app/internal/order"
)

type OrderHandler struct {
    service *order.OrderService
}

func NewOrderHandler(service *order.OrderService) *OrderHandler {
    return &OrderHandler{service: service}
}

type createOrderRequest struct {
    UserID string `json:"user_id"`
    Items  []struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
    } `json:"items"`
}

type createOrderResponse struct {
    OrderID string `json:"order_id"`
    Message string `json:"message"`
}

func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
    // HTTP concern: parse request
    var req createOrderRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        writeError(w, http.StatusBadRequest, "invalid request body")
        return
    }

    // Terjemahkan HTTP request ke service request
    items := make([]order.CreateOrderItem, len(req.Items))
    for i, item := range req.Items {
        items[i] = order.CreateOrderItem{
            ProductID: item.ProductID,
            Quantity:  item.Quantity,
        }
    }

    orderID, err := h.service.CreateOrder(r.Context(), order.CreateOrderRequest{
        UserID: req.UserID,
        Items:  items,
    })
    if err != nil {
        // Terjemahkan domain error ke HTTP status
        switch {
        case errors.Is(err, order.ErrUserNotActive):
            writeError(w, http.StatusForbidden, err.Error())
        case errors.Is(err, order.ErrValidation):
            writeError(w, http.StatusUnprocessableEntity, err.Error())
        default:
            writeError(w, http.StatusInternalServerError, "internal server error")
        }
        return
    }

    // HTTP concern: format response
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(createOrderResponse{
        OrderID: orderID,
        Message: "order created successfully",
    })
}

// Concern: HTTP transport — parse request, terjemahkan error, format response
// Tidak tahu: SQL, business logic kalkulasi harga, aturan domain

// ANTI-PATTERN: autentikasi, logging, dan rate limit semua dalam handler
func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
    // === Concern: autentikasi ===
    token := r.Header.Get("Authorization")
    userID, err := validateJWT(token)
    if err != nil {
        http.Error(w, "unauthorized", 401)
        return
    }

    // === Concern: logging ===
    start := time.Now()
    defer func() {
        log.Printf("POST /orders user=%s duration=%v", userID, time.Since(start))
    }()

    // === Concern: rate limiting ===
    if !rateLimiter.Allow(userID) {
        http.Error(w, "too many requests", 429)
        return
    }

    // === Concern: business logic ===
    // ... baru mulai di sini
}

// BENAR: setiap concern ada di middleware-nya sendiri
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        userID, err := validateJWT(token)
        if err != nil {
            http.Error(w, "unauthorized", http.StatusUnauthorized)
            return
        }
        ctx := context.WithValue(r.Context(), contextKeyUserID, userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        rec := &statusRecorder{ResponseWriter: w, status: 200}
        next.ServeHTTP(rec, r)
        slog.Info("request",
            "method", r.Method,
            "path", r.URL.Path,
            "status", rec.status,
            "duration", time.Since(start),
        )
    })
}

func RateLimitMiddleware(limiter *rate.Limiter) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if !limiter.Allow() {
                http.Error(w, "too many requests", http.StatusTooManyRequests)
                return
            }
            next.ServeHTTP(w, r)
        })
    }
}

// Handler sekarang hanya punya satu concern: business logic untuk endpoint ini
func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(contextKeyUserID).(string)
    // ... langsung ke business logic
}

// Middleware stack didefinisikan di satu tempat
router.Use(LoggingMiddleware)
router.Use(AuthMiddleware)
router.Use(RateLimitMiddleware(limiter))
router.POST("/orders", handler.Create)

// ANTI-PATTERN: semua concern dalam satu widget
class OrderListScreen extends StatefulWidget {
    @override
    State<OrderListScreen> createState() => _OrderListScreenState();
}

class _OrderListScreenState extends State<OrderListScreen> {
    List<Order> _orders = [];
    bool _loading = false;

    @override
    void initState() {
        super.initState();
        _loadOrders();
    }

    Future<void> _loadOrders() async {
        setState(() => _loading = true);
        try {
            // === Data access concern di dalam widget ===
            final response = await http.get(
                Uri.parse('https://api.example.com/orders'),
                headers: {'Authorization': 'Bearer ${authToken}'},
            );
            final data = jsonDecode(response.body) as List;

            // === Business logic di dalam widget ===
            final orders = data
                .map((e) => Order.fromJson(e))
                .where((o) => o.total > 0) // business rule di widget
                .toList();

            setState(() {
                _orders = orders;
                _loading = false;
            });
        } catch (e) {
            // === Error handling di widget ===
            setState(() => _loading = false);
        }
    }

    @override
    Widget build(BuildContext context) {
        // Tidak bisa unit test logika filtering tanpa render widget
        if (_loading) return const CircularProgressIndicator();
        return ListView.builder(
            itemCount: _orders.length,
            itemBuilder: (ctx, i) => OrderTile(order: _orders[i]),
        );
    }
}

// BENAR: setiap concern dipisahkan ke tempatnya

// Data access concern
abstract class OrderRepository {
    Future<List<Order>> getOrders();
}

class HttpOrderRepository implements OrderRepository {
    final http.Client _client;
    final String _baseUrl;
    final String _token;

    HttpOrderRepository({
        required http.Client client,
        required String baseUrl,
        required String token,
    }) : _client = client, _baseUrl = baseUrl, _token = token;

    @override
    Future<List<Order>> getOrders() async {
        final response = await _client.get(
            Uri.parse('$_baseUrl/orders'),
            headers: {'Authorization': 'Bearer $_token'},
        );
        if (response.statusCode != 200) {
            throw ApiException(response.statusCode);
        }
        final data = jsonDecode(response.body) as List;
        return data.map((e) => Order.fromJson(e)).toList();
    }
}

// Business logic concern
class OrderViewModel extends ChangeNotifier {
    final OrderRepository _repository;

    List<Order> orders = [];
    bool isLoading = false;
    String? error;

    OrderViewModel(this._repository);

    Future<void> loadOrders() async {
        isLoading = true;
        error = null;
        notifyListeners();

        try {
            final all = await _repository.getOrders();
            // Business rule ada di ViewModel, bisa ditest tanpa widget
            orders = all.where((o) => o.total > 0).toList();
        } catch (e) {
            error = 'Failed to load orders';
        } finally {
            isLoading = false;
            notifyListeners();
        }
    }
}

// UI concern
class OrderListScreen extends StatelessWidget {
    const OrderListScreen({super.key});

    @override
    Widget build(BuildContext context) {
        return ChangeNotifierProvider(
            create: (_) => OrderViewModel(context.read<OrderRepository>())..loadOrders(),
            child: Consumer<OrderViewModel>(
                builder: (context, vm, _) {
                    if (vm.isLoading) return const Center(child: CircularProgressIndicator());
                    if (vm.error != null) return Center(child: Text(vm.error!));
                    return ListView.builder(
                        itemCount: vm.orders.length,
                        itemBuilder: (ctx, i) => OrderTile(order: vm.orders[i]),
                    );
                },
            ),
        );
    }
}
// Business rule (filter total > 0) sekarang ada di ViewModel
// Bisa ditest dengan FakeOrderRepository tanpa render widget

// ✗ Handler yang tahu SQL
func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
    // ... parse request ...
    db.Exec("INSERT INTO orders ...") // HTTP concern tahu SQL
}

// ✗ Service yang tahu JSON
func (s *OrderService) CreateOrder(req *http.Request) {
    var body struct { ... }
    json.NewDecoder(req.Body).Decode(&body) // business concern tahu HTTP
}

// ✗ Repository yang punya business logic
func (r *OrderRepository) SaveWithDiscount(order Order) error {
    if order.UserTier == "gold" {
        order.Total *= 0.85 // data access concern tahu business rule
    }
    r.db.Exec("INSERT INTO orders ...", order.Total)
    return nil
}

// ✗ Domain entity yang tahu cara disimpan
type Order struct { ... }
func (o *Order) Save(db *sql.DB) error { // domain entity tahu SQL
    db.Exec("INSERT INTO orders ...")
    return nil
}

// ✗ Widget Flutter yang langsung HTTP call
class OrderWidget extends StatefulWidget {
    void _load() async {
        final resp = await http.get(Uri.parse("https://api.example.com/orders"))
        // UI concern tahu network detail
    }
}