Лекція 10. Шарувата архітектура та конвеєри обробки запитів

# Створюємо теку проєкту
mkdir myapp
cd myapp

# Ініціалізуємо Go-модуль
go mod init myapp

# Встановлюємо необхідні залежності
go get github.com/go-chi/chi/v5
go get golang.org/x/time/rate
go get golang.org/x/crypto/bcrypt
go get github.com/lib/pq  # PostgreSQL драйвер
go get github.com/google/uuid  # UUID generation

// go.mod
module myapp

go 1.21

require (
    github.com/go-chi/chi/v5 v5.0.11
    github.com/google/uuid v1.5.0
    github.com/lib/pq v1.10.9
    golang.org/x/crypto v0.17.0
    golang.org/x/time v0.5.0
)

# Створюємо структуру проєкту
mkdir -p cmd/server
mkdir -p internal/{domain,usecase,repository/{memory,postgres},delivery/http}
mkdir -p middleware
mkdir -p migrations

# Створюємо основні файли
touch cmd/server/main.go
touch middleware/{logger,recovery,cors,ratelimit,auth}.go
touch internal/domain/{user,user_repository,errors}.go
touch internal/usecase/user_usecase.go
touch internal/repository/memory/user_repository.go
touch internal/repository/postgres/user_repository.go
touch internal/delivery/http/user_handler.go

// cmd/simple-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
)

// Примітка: для запуску цього прикладу достатньо стандартної бібліотеки Go

// Глобальна змінна для зберігання користувачів (in-memory)
var users = make(map[string]string)

func main() {
    http.HandleFunc("/api/users", handleUsers)
    http.HandleFunc("/api/health", handleHealth)

    fmt.Println("Server starting on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleUsers(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    log.Printf("[%s] %s - started", r.Method, r.URL.Path)

    switch r.Method {
    case http.MethodGet:
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
        
    case http.MethodPost:
        var user struct {
            Name  string `json:"name"`
            Email string `json:"email"`
        }
        
        if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
            http.Error(w, "Invalid JSON", http.StatusBadRequest)
            log.Printf("[%s] %s - completed in %v (error: invalid JSON)", 
                r.Method, r.URL.Path, time.Since(start))
            return
        }
        
        users[user.Email] = user.Name
        w.WriteHeader(http.StatusCreated)
        fmt.Fprintf(w, "User %s created", user.Name)
        
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }

    log.Printf("[%s] %s - completed in %v", r.Method, r.URL.Path, time.Since(start))
}

func handleHealth(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    log.Printf("[%s] %s - started", r.Method, r.URL.Path)
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "status": "ok",
        "time":   time.Now().Format(time.RFC3339),
    })
    
    log.Printf("[%s] %s - completed in %v", r.Method, r.URL.Path, time.Since(start))
}

func logRequest(method, path string, start time.Time, stage string) {
    if stage == "start" {
        log.Printf("[%s] %s - started", method, path)
    } else {
        log.Printf("[%s] %s - completed in %v", method, path, time.Since(start))
    }
}

func handleUsers(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    logRequest(r.Method, r.URL.Path, start, "start")
    defer logRequest(r.Method, r.URL.Path, start, "end")
    
    // ... решта логіки
}

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("[%s] %s - started", r.Method, r.URL.Path)
        
        // Викликаємо оригінальний обробник
        next(w, r)
        
        log.Printf("[%s] %s - completed in %v", r.Method, r.URL.Path, time.Since(start))
    }
}

func main() {
    http.HandleFunc("/api/users", withLogging(handleUsers))
    http.HandleFunc("/api/health", withLogging(handleHealth))
    
    log.Fatal(http.ListenAndServe(":8080", nil))
}

type Middleware func(http.Handler) http.Handler

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// Простий обробник як структура
type MyHandler struct{}

func (h *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello from MyHandler")
}

// Використання
http.Handle("/test", &MyHandler{})

// HandlerFunc — це адаптер, що перетворює функцію на Handler
type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

func myHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello")
}

http.Handle("/test", http.HandlerFunc(myHandler))

// middleware/simple.go
package middleware

import (
    "fmt"
    "net/http"
)

// Simple — найпростіший Middleware для демонстрації концепції
func Simple(next http.Handler) http.Handler {
    // Повертаємо нову функцію, що обгортає next
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("BEFORE: Middleware executed before handler")
        
        // Викликаємо наступний обробник у ланцюжку
        next.ServeHTTP(w, r)
        
        fmt.Println("AFTER: Middleware executed after handler")
    })
}

// cmd/middleware-demo/main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    
    "myapp/middleware"  // Наш власний пакет
)

func mainHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello from main handler!")
    fmt.Println("HANDLER: Main handler executing")
}

func main() {
    // Обгортаємо handler у Middleware
    wrappedHandler := middleware.Simple(http.HandlerFunc(mainHandler))
    
    http.Handle("/", wrappedHandler)
    
    fmt.Println("Server starting on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// middleware/logger.go
package middleware

import (
    "log"
    "net/http"
    "time"
)

// Logger — Middleware для логування HTTP-запитів
func Logger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Записуємо час початку обробки
        start := time.Now()
        
        // Логуємо деталі запиту
        log.Printf(
            "[START] Method=%s Path=%s RemoteAddr=%s",
            r.Method,
            r.URL.Path,
            r.RemoteAddr,
        )
        
        // Викликаємо наступний обробник
        next.ServeHTTP(w, r)
        
        // Обчислюємо тривалість обробки
        duration := time.Since(start)
        
        // Логуємо завершення
        log.Printf(
            "[END] Method=%s Path=%s Duration=%v",
            r.Method,
            r.URL.Path,
            duration,
        )
    })
}

// middleware/logger.go (покращена версія)
package middleware

import (
    "log"
    "net/http"
    "time"
)

// responseWriter — обгортка для http.ResponseWriter, що зберігає статус-код
type responseWriter struct {
    http.ResponseWriter
    statusCode int
    written    bool
}

// WriteHeader перехоплює виклик та зберігає статус-код
func (rw *responseWriter) WriteHeader(code int) {
    if !rw.written {
        rw.statusCode = code
        rw.written = true
        rw.ResponseWriter.WriteHeader(code)
    }
}

// Write перехоплює запис даних (якщо WriteHeader не викликано, статус 200)
func (rw *responseWriter) Write(b []byte) (int, error) {
    if !rw.written {
        rw.statusCode = http.StatusOK
        rw.written = true
    }
    return rw.ResponseWriter.Write(b)
}

// Logger — Middleware з логуванням статус-коду
func Logger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Обгортаємо ResponseWriter
        wrapped := &responseWriter{
            ResponseWriter: w,
            statusCode:     http.StatusOK, // за замовчуванням 200
            written:        false,
        }
        
        log.Printf(
            "[→] %s %s from %s",
            r.Method,
            r.URL.Path,
            r.RemoteAddr,
        )
        
        // Викликаємо наступний обробник з обгорнутим writer
        next.ServeHTTP(wrapped, r)
        
        duration := time.Since(start)
        
        log.Printf(
            "[←] %s %s → %d (%v)",
            r.Method,
            r.URL.Path,
            wrapped.statusCode,
            duration,
        )
    })
}

// cmd/logger-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"
)

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "status": "healthy",
    })
}

func errorHandler(w http.ResponseWriter, r *http.Request) {
    http.Error(w, "Something went wrong", http.StatusInternalServerError)
}

func main() {
    // Обгортаємо кожен handler у Logger Middleware
    http.Handle("/health", middleware.Logger(http.HandlerFunc(healthHandler)))
    http.Handle("/error", middleware.Logger(http.HandlerFunc(errorHandler)))
    
    fmt.Println("Server with logging starting on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// middleware/recovery.go
package middleware

import (
    "log"
    "net/http"
    "runtime/debug"
)

// Recovery — Middleware для перехоплення паніки
func Recovery(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Логуємо паніку та стек викликів
                log.Printf("PANIC: %v\n%s", err, debug.Stack())
                
                // Повертаємо клієнту статус 500
                http.Error(w, 
                    "Internal Server Error", 
                    http.StatusInternalServerError)
            }
        }()
        
        // Викликаємо наступний обробник
        next.ServeHTTP(w, r)
    })
}

// cmd/recovery-demo/main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"
)

func panicHandler(w http.ResponseWriter, r *http.Request) {
    // Навмисна паніка для демонстрації
    panic("Something terrible happened!")
}

func normalHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Everything is fine here")
}

func main() {
    // Обгортаємо handler у Recovery та Logger
    http.Handle("/panic", 
        middleware.Logger(
            middleware.Recovery(
                http.HandlerFunc(panicHandler))))
                
    http.Handle("/normal", 
        middleware.Logger(
            middleware.Recovery(
                http.HandlerFunc(normalHandler))))
    
    fmt.Println("Server with panic recovery on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

handler := middleware.Logger(
    middleware.Recovery(
        middleware.CORS(
            http.HandlerFunc(myHandler))))

// middleware/chain.go
package middleware

import "net/http"

// Chain послідовно застосовує список Middleware до handler
func Chain(h http.Handler, middlewares ...func(http.Handler) http.Handler) http.Handler {
    // Застосовуємо Middleware у зворотному порядку,
    // щоб перший у списку виконувався першим
    for i := len(middlewares) - 1; i >= 0; i-- {
        h = middlewares[i](h)
    }
    return h
}

handler := middleware.Chain(
    http.HandlerFunc(myHandler),
    middleware.Logger,
    middleware.Recovery,
    middleware.CORS,
)

Клієнт: https://myapp.com
API:    https://api.myserver.com  ← Різні домени!

OPTIONS /api/users HTTP/1.1
Origin: https://myapp.com
Access-Control-Request-Method: POST
Access-Control-Request-Headers: Content-Type, Authorization

HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://myapp.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400

// middleware/cors.go
package middleware

import (
    "net/http"
    "strings"
)

// CORSConfig — налаштування CORS
type CORSConfig struct {
    AllowOrigins     []string // Дозволені домени (["*"] = всі)
    AllowMethods     []string // Дозволені HTTP-методи
    AllowHeaders     []string // Дозволені заголовки
    ExposeHeaders    []string // Заголовки, доступні клієнту
    AllowCredentials bool     // Дозволити cookies
    MaxAge           int      // Час кешування preflight (секунди)
}

// DefaultCORSConfig — базова конфігурація
func DefaultCORSConfig() CORSConfig {
    return CORSConfig{
        AllowOrigins:  []string{"*"},
        AllowMethods:  []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
        AllowHeaders:  []string{"Origin", "Content-Type", "Accept", "Authorization"},
        ExposeHeaders: []string{},
        AllowCredentials: false,
        MaxAge:        86400, // 24 години
    }
}

// CORS — Middleware для обробки крос-доменних запитів
func CORS(config CORSConfig) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            
            // Перевіряємо, чи дозволений домен
            allowedOrigin := ""
            for _, allowed := range config.AllowOrigins {
                if allowed == "*" || allowed == origin {
                    allowedOrigin = allowed
                    break
                }
            }
            
            // Якщо домен дозволений, встановлюємо заголовки
            if allowedOrigin != "" {
                if allowedOrigin == "*" {
                    w.Header().Set("Access-Control-Allow-Origin", "*")
                } else {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                }
                
                w.Header().Set("Access-Control-Allow-Methods", 
                    strings.Join(config.AllowMethods, ", "))
                w.Header().Set("Access-Control-Allow-Headers", 
                    strings.Join(config.AllowHeaders, ", "))
                
                if len(config.ExposeHeaders) > 0 {
                    w.Header().Set("Access-Control-Expose-Headers", 
                        strings.Join(config.ExposeHeaders, ", "))
                }
                
                if config.AllowCredentials {
                    w.Header().Set("Access-Control-Allow-Credentials", "true")
                }
                
                if config.MaxAge > 0 {
                    w.Header().Set("Access-Control-Max-Age", 
                        fmt.Sprintf("%d", config.MaxAge))
                }
            }
            
            // Preflight-запит (OPTIONS) — відповідаємо одразу
            if r.Method == http.MethodOptions {
                w.WriteHeader(http.StatusNoContent)
                return
            }
            
            // Інші запити — передаємо далі
            next.ServeHTTP(w, r)
        })
    }
}

// cmd/cors-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"
)

func apiHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "message": "API доступне з будь-якого домену",
    })
}

func main() {
    corsConfig := middleware.DefaultCORSConfig()
    
    handler := middleware.Chain(
        http.HandlerFunc(apiHandler),
        middleware.Logger,
        middleware.Recovery,
        middleware.CORS(corsConfig),
    )
    
    http.Handle("/api/data", handler)
    
    fmt.Println("CORS-enabled server on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

<!-- test.html -->
<!DOCTYPE html>
<html>
<head>
    <title>CORS Test</title>
</head>
<body>
    <button onclick="fetchData()">Fetch Data</button>
    <pre id="result"></pre>
    
    <script>
        async function fetchData() {
            try {
                const response = await fetch('http://localhost:8080/api/data');
                const data = await response.json();
                document.getElementById('result').textContent = 
                    JSON.stringify(data, null, 2);
            } catch (error) {
                document.getElementById('result').textContent = 
                    'Error: ' + error.message;
            }
        }
    </script>
</body>
</html>

go get golang.org/x/time/rate

// middleware/ratelimit.go
package middleware

import (
    "net/http"
    "sync"
    "time"

    "golang.org/x/time/rate"
)

// RateLimiter зберігає окремий лімітер для кожного клієнта
type RateLimiter struct {
    mu       sync.Mutex
    limiters map[string]*rate.Limiter
    rate     rate.Limit
    burst    int
}

// NewRateLimiter створює новий rate limiter
// rps - запитів на секунду, burst - максимальний сплеск
func NewRateLimiter(rps int, burst int) *RateLimiter {
    return &RateLimiter{
        limiters: make(map[string]*rate.Limiter),
        rate:     rate.Limit(rps),
        burst:    burst,
    }
}

// getLimiter отримує або створює лімітер для IP
func (rl *RateLimiter) getLimiter(ip string) *rate.Limiter {
    rl.mu.Lock()
    defer rl.mu.Unlock()
    
    limiter, exists := rl.limiters[ip]
    if !exists {
        limiter = rate.NewLimiter(rl.rate, rl.burst)
        rl.limiters[ip] = limiter
    }
    
    return limiter
}

// Middleware повертає HTTP Middleware
func (rl *RateLimiter) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Отримуємо IP клієнта
        ip := r.RemoteAddr
        
        // Перевіряємо ліміт
        limiter := rl.getLimiter(ip)
        
        if !limiter.Allow() {
            // Ліміт перевищено
            w.Header().Set("X-RateLimit-Retry-After", 
                time.Second.String())
            http.Error(w, 
                "Too Many Requests - Rate limit exceeded", 
                http.StatusTooManyRequests)
            return
        }
        
        // Ліміт не перевищено — передаємо далі
        next.ServeHTTP(w, r)
    })
}

// cmd/ratelimit-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"
)

func dataHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "data": "This endpoint is rate-limited to 2 req/sec",
    })
}

func main() {
    // Дозволяємо 2 запити на секунду, сплеск до 5
    rateLimiter := middleware.NewRateLimiter(2, 5)
    
    handler := middleware.Chain(
        http.HandlerFunc(dataHandler),
        middleware.Logger,
        middleware.Recovery,
        rateLimiter.Middleware,
    )
    
    http.Handle("/api/data", handler)
    
    fmt.Println("Rate-limited server (2 req/s) on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// middleware/auth.go
package middleware

import (
    "context"
    "net/http"
    "strings"
)

// contextKey — приватний тип для ключів контексту
type contextKey string

const (
    // UserIDKey — ключ для збереження user_id у контексті
    UserIDKey contextKey = "user_id"
)

// middleware/auth.go (продовження)
package middleware

import (
    "context"
    "fmt"
    "net/http"
    "strings"
)

// Auth — Middleware для перевірки Bearer токена
func Auth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Читаємо заголовок Authorization
        authHeader := r.Header.Get("Authorization")
        if authHeader == "" {
            http.Error(w, 
                "Missing Authorization header", 
                http.StatusUnauthorized)
            return
        }
        
        // Очікуємо формат: "Bearer <token>"
        parts := strings.Split(authHeader, " ")
        if len(parts) != 2 || parts[0] != "Bearer" {
            http.Error(w, 
                "Invalid Authorization header format. Expected: Bearer <token>", 
                http.StatusUnauthorized)
            return
        }
        
        token := parts[1]
        
        // Валідація токена (тут спрощено)
        userID, err := validateJWT(token)
        if err != nil {
            http.Error(w, 
                "Invalid or expired token: " + err.Error(), 
                http.StatusUnauthorized)
            return
        }
        
        // Додаємо user_id у контекст запиту
        ctx := context.WithValue(r.Context(), UserIDKey, userID)
        
        // Передаємо оновлений запит з новим контекстом
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// validateJWT — спрощена валідація токена
// У реальному проєкті тут має бути перевірка підпису JWT
func validateJWT(token string) (string, error) {
    // Для демонстрації: просто повертаємо токен як user_id
    if token == "" {
        return "", fmt.Errorf("empty token")
    }
    
    // У реальності тут буде:
    // 1. Парсинг JWT
    // 2. Перевірка підпису
    // 3. Перевірка термінів дії (exp)
    // 4. Витягування claims (user_id, roles, etc.)
    
    return "user-123", nil // Заглушка
}

// cmd/auth-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"
)

// Публічний ендпоінт (без автентифікації)
func publicHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "message": "This is a public endpoint",
    })
}

// Захищений ендпоінт (вимагає автентифікації)
func protectedHandler(w http.ResponseWriter, r *http.Request) {
    // Витягуємо user_id з контексту
    userID, ok := r.Context().Value(middleware.UserIDKey).(string)
    if !ok {
        http.Error(w, "User not authenticated", http.StatusUnauthorized)
        return
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "message": "This is a protected endpoint",
        "user_id": userID,
    })
}

func main() {
    // Публічний маршрут (без Auth Middleware)
    http.Handle("/api/public", 
        middleware.Chain(
            http.HandlerFunc(publicHandler),
            middleware.Logger,
            middleware.Recovery,
        ))
    
    // Захищений маршрут (з Auth Middleware)
    http.Handle("/api/protected", 
        middleware.Chain(
            http.HandlerFunc(protectedHandler),
            middleware.Logger,
            middleware.Recovery,
            middleware.Auth, // Додаємо автентифікацію
        ))
    
    fmt.Println("Server with authentication on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

go get -u github.com/go-chi/chi/v5

// cmd/chi-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "myapp/middleware"

    "github.com/go-chi/chi/v5"
)

func main() {
    r := chi.NewRouter()
    
    // Глобальні Middleware (застосовуються до всіх маршрутів)
    r.Use(middleware.Logger)
    r.Use(middleware.Recovery)
    
    // Публічні маршрути
    r.Get("/api/public", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{
            "message": "Public endpoint",
        })
    })
    
    // Група захищених маршрутів
    r.Group(func(r chi.Router) {
        r.Use(middleware.Auth) // Auth тільки для цієї групи
        
        r.Get("/api/profile", func(w http.ResponseWriter, r *http.Request) {
            userID := r.Context().Value(middleware.UserIDKey).(string)
            json.NewEncoder(w).Encode(map[string]string{
                "user_id": userID,
                "message": "Your profile",
            })
        })
        
        r.Get("/api/settings", func(w http.ResponseWriter, r *http.Request) {
            userID := r.Context().Value(middleware.UserIDKey).(string)
            json.NewEncoder(w).Encode(map[string]string{
                "user_id": userID,
                "message": "Your settings",
            })
        })
    })
    
    // Адміністративна група з додатковим rate limiting
    r.Group(func(r chi.Router) {
        r.Use(middleware.Auth)
        rateLimiter := middleware.NewRateLimiter(1, 3)
        r.Use(rateLimiter.Middleware)
        
        r.Get("/api/admin/users", func(w http.ResponseWriter, r *http.Request) {
            json.NewEncoder(w).Encode(map[string]string{
                "message": "Admin only - user list",
            })
        })
    })
    
    fmt.Println("Chi server with grouped middleware on :8080...")
    log.Fatal(http.ListenAndServe(":8080", r))
}

// cmd/full-server/main.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
    "myapp/middleware"

    "github.com/go-chi/chi/v5"
)

// Структури даних
type User struct {
    ID        string    `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email"`
    CreatedAt time.Time `json:"created_at"`
}

// In-memory зберігання (у реальності — БД)
var users = map[string]*User{
    "user-1": {
        ID:        "user-1",
        Name:      "John Doe",
        Email:     "john@example.com",
        CreatedAt: time.Now().Add(-24 * time.Hour),
    },
}

func main() {
    r := chi.NewRouter()
    
    // Глобальні Middleware
    r.Use(middleware.Logger)
    r.Use(middleware.Recovery)
    corsConfig := middleware.DefaultCORSConfig()
    r.Use(middleware.CORS(corsConfig))
    
    // Health check
    r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]interface{}{
            "status":    "ok",
            "timestamp": time.Now().Unix(),
        })
    })
    
    // Публічні маршрути
    r.Post("/api/register", registerHandler)
    r.Post("/api/login", loginHandler)
    
    // Захищені маршрути
    r.Group(func(r chi.Router) {
        r.Use(middleware.Auth)
        
        r.Get("/api/users/me", getCurrentUserHandler)
        r.Put("/api/users/me", updateCurrentUserHandler)
    })
    
    // Адмінські маршрути з rate limiting
    r.Group(func(r chi.Router) {
        r.Use(middleware.Auth)
        rateLimiter := middleware.NewRateLimiter(5, 10)
        r.Use(rateLimiter.Middleware)
        
        r.Get("/api/admin/users", listUsersHandler)
        r.Get("/api/admin/stats", getStatsHandler)
    })
    
    fmt.Println("╔════════════════════════════════════════╗")
    fmt.Println("║  Full-featured server on :8080 🚀      ║")
    fmt.Println("╠════════════════════════════════════════╣")
    fmt.Println("║  Endpoints:                            ║")
    fmt.Println("║   GET  /health                         ║")
    fmt.Println("║   POST /api/register                   ║")
    fmt.Println("║   POST /api/login                      ║")
    fmt.Println("║   GET  /api/users/me  (auth)           ║")
    fmt.Println("║   PUT  /api/users/me  (auth)           ║")
    fmt.Println("║   GET  /api/admin/users (auth+limit)   ║")
    fmt.Println("║   GET  /api/admin/stats (auth+limit)   ║")
    fmt.Println("╚════════════════════════════════════════╝")
    
    log.Fatal(http.ListenAndServe(":8080", r))
}

func registerHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Name     string `json:"name"`
        Email    string `json:"email"`
        Password string `json:"password"`
    }
    
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    // Тут має бути хешування пароля і збереження в БД
    newUser := &User{
        ID:        fmt.Sprintf("user-%d", len(users)+1),
        Name:      req.Name,
        Email:     req.Email,
        CreatedAt: time.Now(),
    }
    users[newUser.ID] = newUser
    
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(newUser)
}

func loginHandler(w http.ResponseWriter, r *http.Request) {
    // Спрощена реалізація (у реальності — перевірка паролю, генерація JWT)
    json.NewEncoder(w).Encode(map[string]string{
        "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", // Заглушка
    })
}

func getCurrentUserHandler(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(middleware.UserIDKey).(string)
    
    user, exists := users[userID]
    if !exists {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    
    json.NewEncoder(w).Encode(user)
}

func updateCurrentUserHandler(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(middleware.UserIDKey).(string)
    
    var updates struct {
        Name string `json:"name"`
    }
    if err := json.NewDecoder(r.Body).Decode(&updates); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    user, exists := users[userID]
    if !exists {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    
    user.Name = updates.Name
    json.NewEncoder(w).Encode(user)
}

func listUsersHandler(w http.ResponseWriter, r *http.Request) {
    allUsers := make([]*User, 0, len(users))
    for _, u := range users {
        allUsers = append(allUsers, u)
    }
    json.NewEncoder(w).Encode(allUsers)
}

func getStatsHandler(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(map[string]interface{}{
        "total_users":     len(users),
        "server_uptime":   "24h", // Заглушка
        "requests_today":  12543,  // Заглушка
    })
}

func registerHandler(w http.ResponseWriter, r *http.Request) {
    // 1. Парсинг JSON
    var req struct {
        Name     string `json:"name"`
        Email    string `json:"email"`
        Password string `json:"password"`
    }
    json.NewDecoder(r.Body).Decode(&req)
    
    // 2. Валідація
    if req.Email == "" || req.Password == "" {
        http.Error(w, "Invalid input", http.StatusBadRequest)
        return
    }
    
    // 3. Перевірка існування користувача
    for _, u := range users {
        if u.Email == req.Email {
            http.Error(w, "Email already exists", http.StatusConflict)
            return
        }
    }
    
    // 4. Хешування пароля
    hashedPassword := hashPassword(req.Password)
    
    // 5. Створення користувача
    newUser := &User{
        ID:       generateID(),
        Name:     req.Name,
        Email:    req.Email,
        Password: hashedPassword,
    }
    users[newUser.ID] = newUser
    
    // 6. Формування відповіді
    json.NewEncoder(w).Encode(newUser)
}

// business/user.go
package business

import (
    "errors"
    "fmt"
)

type User struct {
    ID       string
    Name     string
    Email    string
    Password string
}

// RegisterUser — бізнес-логіка реєстрації
func RegisterUser(name, email, password string, existingUsers map[string]*User) (*User, error) {
    // Валідація
    if email == "" || password == "" {
        return nil, errors.New("email and password are required")
    }
    
    if len(password) < 8 {
        return nil, errors.New("password must be at least 8 characters")
    }
    
    // Перевірка дублікатів
    for _, u := range existingUsers {
        if u.Email == email {
            return nil, errors.New("email already exists")
        }
    }
    
    // Хешування пароля
    hashedPassword := hashPassword(password)
    
    // Створення користувача
    user := &User{
        ID:       fmt.Sprintf("user-%d", len(existingUsers)+1),
        Name:     name,
        Email:    email,
        Password: hashedPassword,
    }
    
    return user, nil
}

func hashPassword(password string) string {
    // Спрощена реалізація
    return "hashed_" + password
}

func registerHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Name     string `json:"name"`
        Email    string `json:"email"`
        Password string `json:"password"`
    }
    
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    // Викликаємо бізнес-логіку
    user, err := business.RegisterUser(req.Name, req.Email, req.Password, users)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    // Зберігаємо користувача
    users[user.ID] = user
    
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

// internal/domain/user.go
package domain

import (
    "errors"
    "regexp"
    "time"
)

// User — доменна сутність користувача
type User struct {
    ID        string
    Name      string
    Email     string
    Password  string // Хеш пароля
    CreatedAt time.Time
    UpdatedAt time.Time
}

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

// Validate перевіряє коректність даних користувача
func (u *User) Validate() error {
    if u.Name == "" {
        return errors.New("name is required")
    }
    
    if u.Email == "" {
        return errors.New("email is required")
    }
    
    if !emailRegex.MatchString(u.Email) {
        return errors.New("invalid email format")
    }
    
    if len(u.Password) < 8 {
        return errors.New("password must be at least 8 characters")
    }
    
    return nil
}

// IsPasswordValid перевіряє відповідність пароля хешу
func (u *User) IsPasswordValid(plainPassword string) bool {
    // У реальності тут bcrypt.CompareHashAndPassword
    return "hashed_"+plainPassword == u.Password
}

// internal/domain/user_repository.go
package domain

import "context"

// UserRepository — інтерфейс для доступу до даних користувачів
type UserRepository interface {
    Create(ctx context.Context, user *User) error
    FindByID(ctx context.Context, id string) (*User, error)
    FindByEmail(ctx context.Context, email string) (*User, error)
    Update(ctx context.Context, user *User) error
    Delete(ctx context.Context, id string) error
}

// Стандартні помилки домену
var (
    ErrUserNotFound      = errors.New("user not found")
    ErrUserAlreadyExists = errors.New("user already exists")
    ErrInvalidCredentials = errors.New("invalid credentials")
)

// internal/usecase/user_usecase.go
package usecase

import (
    "context"
    "myapp/internal/domain"
    "time"

    "golang.org/x/crypto/bcrypt"
)

// UserUseCase — бізнес-логіка роботи з користувачами
type UserUseCase struct {
    repo domain.UserRepository
}

// NewUserUseCase створює новий UseCase
func NewUserUseCase(repo domain.UserRepository) *UserUseCase {
    return &UserUseCase{repo: repo}
}

// RegisterUser реєструє нового користувача
func (uc *UserUseCase) RegisterUser(ctx context.Context, name, email, plainPassword string) (*domain.User, error) {
    // 1. Перевіряємо, чи не існує користувач з таким email
    existing, _ := uc.repo.FindByEmail(ctx, email)
    if existing != nil {
        return nil, domain.ErrUserAlreadyExists
    }
    
    // 2. Хешуємо пароль
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(plainPassword), bcrypt.DefaultCost)
    if err != nil {
        return nil, err
    }
    
    // 3. Створюємо доменну сутність
    user := &domain.User{
        ID:        generateUserID(),
        Name:      name,
        Email:     email,
        Password:  string(hashedPassword),
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }
    
    // 4. Валідуємо доменні правила
    if err := user.Validate(); err != nil {
        return nil, err
    }
    
    // 5. Зберігаємо через репозиторій
    if err := uc.repo.Create(ctx, user); err != nil {
        return nil, err
    }
    
    return user, nil
}

// Login виконує вхід користувача
func (uc *UserUseCase) Login(ctx context.Context, email, plainPassword string) (*domain.User, error) {
    // 1. Знаходимо користувача
    user, err := uc.repo.FindByEmail(ctx, email)
    if err != nil {
        return nil, domain.ErrInvalidCredentials
    }
    
    // 2. Перевіряємо пароль
    if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(plainPassword)); err != nil {
        return nil, domain.ErrInvalidCredentials
    }
    
    return user, nil
}

func generateUserID() string {
    // У реальності: UUID або ULID
    return fmt.Sprintf("user-%d", time.Now().UnixNano())
}