SoC — Separation of Concerns #

// ANTI-PATTERN: all concerns in one function
// HTTP, validation, business logic, database, response — all here
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: Validation ===
    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: Check user (business rule) — direct 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: Calculate 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: Save the 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 the 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",
    })
}
// Testing this function requires: an HTTP server + a populated database
// The "calculate total" business logic can't be tested independently
// The same logic can't be reused from a background worker

// internal/order/domain.go
package order

import (
    "errors"
    "time"
)

// Order is a domain entity — doesn't know HTTP, doesn't know 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 rules attach to the domain, not to handlers or services
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: data representation and core domain rules
// Doesn't know: how data is stored, how requests arrive, how responses are formatted

// internal/order/repository.go
package order

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

// OrderRepository is an interface — depends on abstraction (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: how data is stored and retrieved from the database
// Doesn't know: HTTP, business rules, how input is validated

// 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: check the user is active
    active, err := s.users.IsActive(ctx, req.UserID)
    if err != nil {
        return "", fmt.Errorf("createOrder: check user: %w", err)
    }
    if !active {
        return "", ErrUserNotActive
    }

    // Build the domain entity with prices from the 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,
    }

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

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

    return orderID, nil
}

// Concern: business logic orchestration
// Doesn't know: HTTP, SQL queries, JSON formatting

// 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 the request
    var req createOrderRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        writeError(w, http.StatusBadRequest, "invalid request body")
        return
    }

    // Translate the HTTP request into a 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 {
        // Translate domain errors into HTTP statuses
        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 the 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 requests, translate errors, format responses
// Doesn't know: SQL, price calculation business logic, domain rules

// ANTI-PATTERN: authentication, logging, and rate limiting all in the handler
func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
    // === Concern: authentication ===
    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 ===
    // ... only starts here
}

// CORRECT: each concern has its own middleware
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)
        })
    }
}

// The handler now has only one concern: business logic for this endpoint
func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(contextKeyUserID).(string)
    // ... straight to business logic
}

// The middleware stack is defined in one place
router.Use(LoggingMiddleware)
router.Use(AuthMiddleware)
router.Use(RateLimitMiddleware(limiter))
router.POST("/orders", handler.Create)

// ANTI-PATTERN: all concerns in one widget
class OrderListActivity extends AppCompatActivity {
    private final List<Order> orders = new ArrayList<>();
    private boolean loading = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        loadOrders();
    }

    void loadOrders() {
        loading = true;
        new Thread(() -> {
            try {
                // === Data access concern inside the widget ===
                HttpURLConnection conn = (HttpURLConnection)
                        new URL("https://api.example.com/orders").openConnection();
                conn.setRequestProperty("Authorization", "Bearer " + authToken);
                String body = new String(conn.getInputStream().readAllBytes());
                List<Order> data = Order.parseAll(body);

                // === Business logic inside the widget ===
                List<Order> filtered = new ArrayList<>();
                for (Order o : data) {
                    if (o.total > 0) { // business rule in a widget
                        filtered.add(o);
                    }
                }

                runOnUiThread(() -> {
                    orders.clear();
                    orders.addAll(filtered);
                    loading = false;
                    adapter.notifyDataSetChanged();
                });
            } catch (Exception e) {
                // === Error handling inside the widget ===
                runOnUiThread(() -> loading = false);
            }
        }).start();
    }

    // Can't unit test the filtering logic without rendering the widget
}

// CORRECT: each concern separated into its place

// Data access concern
interface OrderRepository {
    List<Order> getOrders();
}

class HttpOrderRepository implements OrderRepository {
    private final String baseUrl;
    private final String token;

    HttpOrderRepository(String baseUrl, String token) {
        this.baseUrl = baseUrl;
        this.token = token;
    }

    @Override
    public List<Order> getOrders() {
        HttpURLConnection conn = (HttpURLConnection) new URL(baseUrl + "/orders").openConnection();
        conn.setRequestProperty("Authorization", "Bearer " + token);
        if (conn.getResponseCode() != 200) {
            throw new ApiException(conn.getResponseCode());
        }
        String body = new String(conn.getInputStream().readAllBytes());
        return Order.parseAll(body);
    }
}

// Business logic concern
class OrderViewModel {
    private final OrderRepository repository;
    private final List<Order> orders = new ArrayList<>();
    private boolean loading = false;
    private String error;

    OrderViewModel(OrderRepository repository) {
        this.repository = repository;
    }

    void loadOrders() {
        loading = true;
        error = null;
        notifyListeners();

        new Thread(() -> {
            try {
                List<Order> all = repository.getOrders();
                // Business rules live in the ViewModel, testable without widgets
                List<Order> filtered = new ArrayList<>();
                for (Order o : all) {
                    if (o.total > 0) {
                        filtered.add(o);
                    }
                }
                orders.clear();
                orders.addAll(filtered);
            } catch (Exception e) {
                error = "Failed to load orders";
            } finally {
                loading = false;
                notifyListeners();
            }
        }).start();
    }
}

// UI concern
class OrderListActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        OrderViewModel vm = new OrderViewModel(new HttpOrderRepository(baseUrl, token));
        vm.loadOrders();
        // The activity only renders state from the ViewModel
        if (vm.isLoading()) {
            showLoadingIndicator();
        } else if (vm.getError() != null) {
            showError(vm.getError());
        } else {
            showOrders(vm.getOrders());
        }
    }
}
// The business rule (total > 0 filter) now lives in the ViewModel
// Testable with a FakeOrderRepository without rendering any widget

// ✗ A handler that knows SQL
func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
    // ... parse request ...
    db.Exec("INSERT INTO orders ...") // HTTP concern knows SQL
}

// ✗ A service that knows JSON
func (s *OrderService) CreateOrder(req *http.Request) {
    var body struct { ... }
    json.NewDecoder(req.Body).Decode(&body) // business concern knows HTTP
}

// ✗ A repository with business logic
func (r *OrderRepository) SaveWithDiscount(order Order) error {
    if order.UserTier == "gold" {
        order.Total *= 0.85 // data access concern knows business rules
    }
    r.db.Exec("INSERT INTO orders ...", order.Total)
    return nil
}

// ✗ A domain entity that knows how it's stored
type Order struct { ... }
func (o *Order) Save(db *sql.DB) error { // domain entity knows SQL
    db.Exec("INSERT INTO orders ...")
    return nil
}

// ✗ A Flutter widget making direct HTTP calls
class OrderWidget extends StatefulWidget {
    void _load() async {
        final resp = await http.get(Uri.parse("https://api.example.com/orders"))
        // UI concern knows network details
    }
}