GET адрес_документа

POST /v1/orders HTTP/1.1
Host: api.coffeeshop.dev
Content-Type: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Content-Length: 147

{
  "coffee_machine_id": 123,
  "recipe": "lungo",
  "volume": "800ml",
  "price": {
    "amount": "10.23",
    "currency": "UAH"
  }
}

https://api.coffeeshop.dev:443/v1/orders/123?include=items&format=json#section
└───┘   └──────────────────┘ └─┘ └──────────┘ └────────────────────┘ └──────┘
схема        хост          порт     шлях         параметри запиту    фрагмент

X-CoffeeAPI-Request-ID: 7f3a8b2c-1e4d-4a9b-8c3f-2d1e4a7b9c3f
X-CoffeeAPI-Client-Version: 2.5.1

GET /v1/state HTTP/1.1
Authorization: Bearer <token>

→ HTTP/1.1 200 OK
{
  "profile": {
    "user_id": "user_123",
    "name": "Андрій Петренко",
    "email": "andrii@example.com"
  },
  "orders": [
    {"id": "order_456", "status": "pending", "recipe": "espresso"},
    {"id": "order_789", "status": "completed", "recipe": "cappuccino"}
  ]
}

GET /v1/profiles/{user_id} HTTP/1.1

→ HTTP/1.1 200 OK
Cache-Control: max-age=3600
{
  "user_id": "user_123",
  "name": "Андрій Петренко",
  "email": "andrii@example.com"
}

GET /v1/orders?user_id=user_123 HTTP/1.1

→ HTTP/1.1 200 OK
ETag: "v123abc"
Cache-Control: no-cache
[
  {"id": "order_456", "status": "pending", "recipe": "espresso"},
  {"id": "order_789", "status": "completed", "recipe": "cappuccino"}
]

POST /v1/orders HTTP/1.1
Content-Type: application/json

{
  "user_id": "user_123",
  "recipe": "espresso",
  "volume": "50ml"
}

→ HTTP/1.1 201 Created
Location: /v1/orders/order_456
{
  "id": "order_456",
  "user_id": "user_123",
  "recipe": "espresso",
  "status": "pending"
}

POST /v1/orders HTTP/1.1
Idempotency-Key: 7f3a8b2c-1e4d-4a9b-8c3f-2d1e4a7b9c3f
Content-Type: application/json

{
  "user_id": "user_123",
  "recipe": "espresso"
}

POST /v1/drafts HTTP/1.1
{"user_id": "user_123", "recipe": "espresso"}

→ 201 Created
Location: /v1/drafts/draft_789

PUT /v1/drafts/draft_789/commit HTTP/1.1
{"confirm": true}

→ 200 OK
Location: /v1/orders/order_456

GET /v1/orders/123 HTTP/1.1

→ HTTP/1.1 200 OK
{
  "id": "order_123",
  "user_id": "user_456",
  "recipe": "cappuccino",
  "status": "completed"
}

GET /v1/orders?user_id=user_456&status=pending&limit=20&offset=0

POST /v1/orders/search HTTP/1.1
{
  "filters": {
    "recipes": ["espresso", "cappuccino"],
    "date_range": {"start": "2026-01-01", "end": "2026-12-31"}
  },
  "sort": {"field": "created_at", "order": "desc"},
  "pagination": {"limit": 50, "offset": 0}
}

PUT /v1/orders/123 HTTP/1.1
Content-Type: application/json

{
  "user_id": "user_456",
  "recipe": "latte",
  "volume": "300ml",
  "status": "pending"
}

→ HTTP/1.1 200 OK
{
  "id": "order_123",
  "user_id": "user_456",
  "recipe": "latte",
  "volume": "300ml",
  "status": "pending"
}

PATCH /v1/orders/123 HTTP/1.1
Content-Type: application/json

{
  "status": "completed"
}

→ HTTP/1.1 200 OK
{
  "id": "order_123",
  "user_id": "user_456",
  "recipe": "espresso",
  "volume": "50ml",
  "status": "completed"
}

PUT /v1/orders/123/archive HTTP/1.1

→ HTTP/1.1 204 No Content

DELETE /v1/orders/123 HTTP/1.1

→ HTTP/1.1 204 No Content

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

package main

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

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

func main() {
    r := chi.NewRouter()

    // Middleware: логування запитів, відновлення після паніки
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)

    // Маршрути
    r.Get("/", homeHandler)
    r.Get("/health", healthCheckHandler)
    r.Route("/v1", func(r chi.Router) {
        r.Get("/orders", listOrdersHandler)
        r.Post("/orders", createOrderHandler)
        r.Get("/orders/{orderID}", getOrderHandler)
        r.Put("/orders/{orderID}", updateOrderHandler)
        r.Delete("/orders/{orderID}", deleteOrderHandler)
    })

    http.ListenAndServe(":8080", r)
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Welcome to Coffee API"))
}

func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(map[string]string{"status": "healthy"})
}

func listOrdersHandler(w http.ResponseWriter, r *http.Request) {
    // Витягуємо query-параметри
    userID := r.URL.Query().Get("user_id")
    // ... логіка отримання списку замовлень
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode([]map[string]interface{}{
        {"id": "order_1", "user_id": userID, "recipe": "espresso"},
    })
}

func getOrderHandler(w http.ResponseWriter, r *http.Request) {
    // Витягуємо параметр шляху
    orderID := chi.URLParam(r, "orderID")
    
    // ... логіка отримання замовлення за ID
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]interface{}{
        "id":     orderID,
        "recipe": "cappuccino",
        "status": "completed",
    })
}

func createOrderHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        UserID string `json:"user_id"`
        Recipe string `json:"recipe"`
    }
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    // ... логіка створення замовлення
    w.WriteHeader(http.StatusCreated)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]interface{}{
        "id":      "order_789",
        "user_id": req.UserID,
        "recipe":  req.Recipe,
        "status":  "pending",
    })
}

func updateOrderHandler(w http.ResponseWriter, r *http.Request) {
    orderID := chi.URLParam(r, "orderID")
    // ... логіка оновлення замовлення
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]string{"id": orderID, "status": "updated"})
}

func deleteOrderHandler(w http.ResponseWriter, r *http.Request) {
    orderID := chi.URLParam(r, "orderID")
    // ... логіка видалення замовлення
    w.WriteHeader(http.StatusNoContent)
}

r.Get("/orders/{orderID}", getOrderHandler)
r.Get("/users/{userID}/orders/{orderID}", getUserOrderHandler)

func getOrderHandler(w http.ResponseWriter, r *http.Request) {
    orderID := chi.URLParam(r, "orderID")
    fmt.Fprintf(w, "Order ID: %s", orderID)
}

r.Route("/v1", func(r chi.Router) {
    // Middleware тільки для /v1/*
    r.Use(corsMiddleware)
    r.Use(authMiddleware)

    r.Get("/health", healthHandler)

    r.Route("/orders", func(r chi.Router) {
        r.Get("/", listOrdersHandler)       // GET /v1/orders
        r.Post("/", createOrderHandler)     // POST /v1/orders
        r.Get("/{id}", getOrderHandler)     // GET /v1/orders/{id}
        r.Put("/{id}", updateOrderHandler)  // PUT /v1/orders/{id}
        r.Delete("/{id}", deleteOrderHandler) // DELETE /v1/orders/{id}
    })
})

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // Викликаємо наступний обробник у ланцюжку
        next.ServeHTTP(w, r)
        
        // Логуємо після виконання запиту
        duration := time.Since(start)
        log.Printf("%s %s %v", r.Method, r.URL.Path, duration)
    })
}

// Застосування middleware
r.Use(loggingMiddleware)

func corsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

        // Обробка preflight-запитів
        if r.Method == http.MethodOptions {
            w.WriteHeader(http.StatusOK)
            return
        }

        next.ServeHTTP(w, r)
    })
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }

        // Перевірка токена (наприклад, JWT)
        userID, err := validateToken(token)
        if err != nil {
            http.Error(w, "Invalid token", http.StatusUnauthorized)
            return
        }

        // Додаємо userID до контексту
        ctx := context.WithValue(r.Context(), "userID", userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

import "github.com/go-chi/chi/v5/middleware"

func main() {
    r := chi.NewRouter()

    // 1. Logger - логування кожного запиту
    r.Use(middleware.Logger)

    // 2. Recoverer - відновлення після паніки
    r.Use(middleware.Recoverer)

    // 3. RequestID - додає унікальний ID до кожного запиту
    r.Use(middleware.RequestID)

    // 4. RealIP - витягує реальний IP клієнта (за проксі)
    r.Use(middleware.RealIP)

    // 5. Timeout - встановлює таймаут для обробки запиту
    r.Use(middleware.Timeout(60 * time.Second))

    // 6. Throttle - обмеження кількості одночасних запитів
    r.Use(middleware.Throttle(100))

    // 7. Compress - стиснення відповідей (gzip, deflate)
    r.Use(middleware.Compress(5))

    // 8. StripSlashes - нормалізація слешів у кінці URL
    r.Use(middleware.StripSlashes)

    // 9. Heartbeat - ендпоінт для health checks
    r.Use(middleware.Heartbeat("/ping"))

    // 10. AllowContentType - дозволяє лише певні Content-Type
    r.Use(middleware.AllowContentType("application/json"))

    // ... ваші маршрути
}

r.Use(middleware.RequestID)

func someHandler(w http.ResponseWriter, r *http.Request) {
    requestID := middleware.GetReqID(r.Context())
    log.Printf("[%s] Processing request", requestID)
    
    // Додаємо Request ID до відповіді для трейсингу
    w.Header().Set("X-Request-ID", requestID)
}

r.Use(middleware.RealIP)

func someHandler(w http.ResponseWriter, r *http.Request) {
    // Витягує IP з заголовків X-Forwarded-For, X-Real-IP
    clientIP := r.RemoteAddr
    log.Printf("Request from IP: %s", clientIP)
}

// Дозволяємо не більше 100 одночасних запитів
r.Use(middleware.Throttle(100))

// Якщо ліміт перевищено, Chi повертає 429 Too Many Requests

// Якщо обробник не встигне відповісти за 30 секунд, 
// Chi поверне 504 Gateway Timeout
r.Use(middleware.Timeout(30 * time.Second))

func slowHandler(w http.ResponseWriter, r *http.Request) {
    // Можна перевірити, чи не скасовано контекст
    select {
    case <-time.After(5 * time.Second):
        w.Write([]byte("Done"))
    case <-r.Context().Done():
        // Таймаут або клієнт розірвав з'єднання
        return
    }
}

func main() {
    r := chi.NewRouter()

    // Монтуємо API v1
    r.Mount("/api/v1", apiV1Router())
    
    // Монтуємо API v2
    r.Mount("/api/v2", apiV2Router())
    
    // Монтуємо адмін-панель
    r.Mount("/admin", adminRouter())

    http.ListenAndServe(":8080", r)
}

func apiV1Router() chi.Router {
    r := chi.NewRouter()
    r.Use(corsMiddleware)
    
    r.Get("/orders", listOrdersHandler)
    r.Post("/orders", createOrderHandler)
    
    return r
}

func apiV2Router() chi.Router {
    r := chi.NewRouter()
    r.Use(corsMiddleware)
    r.Use(authMiddleware) // V2 вимагає автентифікації
    
    r.Get("/orders", listOrdersV2Handler)
    r.Post("/orders", createOrderV2Handler)
    
    return r
}

func adminRouter() chi.Router {
    r := chi.NewRouter()
    r.Use(adminAuthMiddleware) // Окрема автентифікація для адмінів
    
    r.Get("/users", listUsersHandler)
    r.Get("/stats", statsHandler)
    
    return r
}

r := chi.NewRouter()

// Користувацький обробник для 404 Not Found
r.NotFound(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "error": "Route not found",
        "path":  r.URL.Path,
        "method": r.Method,
    })
})

// Користувацький обробник для 405 Method Not Allowed
r.MethodNotAllowed(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusMethodNotAllowed)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "error": fmt.Sprintf("Method %s not allowed for %s", r.Method, r.URL.Path),
        "allowed_methods": []string{"GET", "POST"}, // Можна динамічно визначати
    })
})

// Middleware додає дані до контексту
func userMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        userID := chi.URLParam(r, "userID")
        
        // Завантажуємо користувача з БД
        user, err := getUserFromDB(userID)
        if err != nil {
            http.Error(w, "User not found", http.StatusNotFound)
            return
        }

        // Додаємо користувача до контексту
        ctx := context.WithValue(r.Context(), "user", user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// Обробник витягує дані з контексту
func getUserOrdersHandler(w http.ResponseWriter, r *http.Request) {
    // Витягуємо користувача з контексту
    user := r.Context().Value("user").(*User)
    
    orders := getOrdersForUser(user.ID)
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(orders)
}

// Використання
r.Route("/users/{userID}", func(r chi.Router) {
    r.Use(userMiddleware) // Застосовується до всіх маршрутів нижче
    r.Get("/orders", getUserOrdersHandler)
    r.Get("/profile", getUserProfileHandler)
})

// Тільки числові ID
r.Get("/orders/{orderID:[0-9]+}", getOrderHandler)

// UUID формат
r.Get("/users/{userID:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}}", getUserHandler)

// Дати у форматі YYYY-MM-DD
r.Get("/reports/{date:[0-9]{4}-[0-9]{2}-[0-9]{2}}", getReportHandler)

// Slug (латинські літери, цифри, дефіси)
r.Get("/posts/{slug:[a-z0-9-]+}", getPostHandler)

package main

import (
    "context"
    "encoding/json"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

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

func main() {
    r := chi.NewRouter()

    // Глобальні middleware
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.Timeout(60 * time.Second))
    r.Use(middleware.Compress(5))

    // Health check
    r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{
            "status": "healthy",
            "time":   time.Now().Format(time.RFC3339),
        })
    })

    // API v1
    r.Route("/api/v1", func(r chi.Router) {
        r.Use(corsMiddleware)
        
        // Публічні маршрути
        r.Group(func(r chi.Router) {
            r.Post("/auth/login", loginHandler)
            r.Post("/auth/register", registerHandler)
        })

        // Захищені маршрути
        r.Group(func(r chi.Router) {
            r.Use(authMiddleware)
            
            r.Route("/orders", func(r chi.Router) {
                r.Get("/", listOrdersHandler)
                r.Post("/", createOrderHandler)
                
                r.Route("/{orderID:[0-9]+}", func(r chi.Router) {
                    r.Get("/", getOrderHandler)
                    r.Put("/", updateOrderHandler)
                    r.Delete("/", deleteOrderHandler)
                })
            })
        })
    })

    // Користувацькі обробники помилок
    r.NotFound(notFoundHandler)
    r.MethodNotAllowed(methodNotAllowedHandler)

    // Graceful Shutdown
    srv := &http.Server{
        Addr:         ":8080",
        Handler:      r,
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    go func() {
        log.Printf("🚀 Server starting on %s", srv.Addr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server error: %v", err)
        }
    }()

    // Очікуємо сигнал завершення
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("⏳ Shutting down server...")
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }

    log.Println("✅ Server stopped gracefully")
}

// Заглушки для обробників (реалізуйте власну логіку)
func loginHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func registerHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func listOrdersHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func createOrderHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func getOrderHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func updateOrderHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }
func deleteOrderHandler(w http.ResponseWriter, r *http.Request) { /* ... */ }

func notFoundHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{
        "error": "Route not found",
        "path":  r.URL.Path,
    })
}

func methodNotAllowedHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusMethodNotAllowed)
    json.NewEncoder(w).Encode(map[string]string{
        "error": "Method not allowed",
    })
}

type CreateOrderRequest struct {
    UserID string `json:"user_id"`
    Recipe string `json:"recipe"`
    Volume string `json:"volume"`
}

func createOrderHandler(w http.ResponseWriter, r *http.Request) {
    var req CreateOrderRequest
    
    // Декодуємо JSON з тіла запиту
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    // Валідація
    if req.UserID == "" || req.Recipe == "" {
        http.Error(w, "Missing required fields", http.StatusBadRequest)
        return
    }

    // ... бізнес-логіка

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "id":      "order_123",
        "user_id": req.UserID,
        "recipe":  req.Recipe,
        "status":  "pending",
    })
}

type Order struct {
    ID        string    `json:"id"`
    UserID    string    `json:"user_id"`
    Recipe    string    `json:"recipe"`
    Volume    string    `json:"volume,omitempty"` // Опускається, якщо порожнє
    Status    string    `json:"status"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"-"` // Ніколи не серіалізується
}

type ProblemDetails struct {
    Type     string                 `json:"type"`
    Title    string                 `json:"title"`
    Status   int                    `json:"status"`
    Detail   string                 `json:"detail,omitempty"`
    Instance string                 `json:"instance,omitempty"`
    Extra    map[string]interface{} `json:"-"`
}

func (p ProblemDetails) MarshalJSON() ([]byte, error) {
    type Alias ProblemDetails
    base := Alias(p)
    
    m := make(map[string]interface{})
    data, _ := json.Marshal(base)
    json.Unmarshal(data, &m)
    
    for k, v := range p.Extra {
        m[k] = v
    }
    
    return json.Marshal(m)
}

func respondWithError(w http.ResponseWriter, problem ProblemDetails) {
    w.Header().Set("Content-Type", "application/problem+json")
    w.WriteHeader(problem.Status)
    json.NewEncoder(w).Encode(problem)
}

// Використання
func getOrderHandler(w http.ResponseWriter, r *http.Request) {
    orderID := chi.URLParam(r, "orderID")
    
    // Припустимо, замовлення не знайдено
    if orderID == "999" {
        respondWithError(w, ProblemDetails{
            Type:     "https://api.coffeeshop.dev/errors/order-not-found",
            Title:    "Order Not Found",
            Status:   http.StatusNotFound,
            Detail:   fmt.Sprintf("Order with ID '%s' does not exist", orderID),
            Instance: r.URL.Path,
        })
        return
    }

    // ... повернення замовлення
}

{
  "type": "https://api.coffeeshop.dev/errors/order-not-found",
  "title": "Order Not Found",
  "status": 404,
  "detail": "Order with ID '999' does not exist",
  "instance": "/v1/orders/999"
}

// internal/domain/order.go
package domain

import "time"

type Order struct {
    ID        string
    UserID    string
    Recipe    string
    Volume    string
    Status    OrderStatus
    CreatedAt time.Time
    UpdatedAt time.Time
}

type OrderStatus string

const (
    OrderStatusPending   OrderStatus = "pending"
    OrderStatusPreparing OrderStatus = "preparing"
    OrderStatusCompleted OrderStatus = "completed"
    OrderStatusCancelled OrderStatus = "cancelled"
)

func (o *Order) CanBeCancelled() bool {
    return o.Status == OrderStatusPending || o.Status == OrderStatusPreparing
}

// internal/repository/order_repository.go
package repository

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

type OrderRepository interface {
    FindAll(ctx context.Context, userID string) ([]domain.Order, error)
    FindByID(ctx context.Context, id string) (domain.Order, error)
    Create(ctx context.Context, order *domain.Order) error
    Update(ctx context.Context, order *domain.Order) error
    Delete(ctx context.Context, id string) error
}

// internal/repository/postgres/order_repository.go
package postgres

import (
    "context"
    "myapp/internal/domain"
    "github.com/jackc/pgx/v5/pgxpool"
)

type OrderRepository struct {
    db *pgxpool.Pool
}

func NewOrderRepository(db *pgxpool.Pool) *OrderRepository {
    return &OrderRepository{db: db}
}

func (r *OrderRepository) FindByID(ctx context.Context, id string) (domain.Order, error) {
    var order domain.Order
    query := `
        SELECT id, user_id, recipe, volume, status, created_at, updated_at
        FROM orders
        WHERE id = $1
    `
    err := r.db.QueryRow(ctx, query, id).Scan(
        &order.ID,
        &order.UserID,
        &order.Recipe,
        &order.Volume,
        &order.Status,
        &order.CreatedAt,
        &order.UpdatedAt,
    )
    if err != nil {
        return domain.Order{}, err
    }
    return order, nil
}

func (r *OrderRepository) Create(ctx context.Context, order *domain.Order) error {
    query := `
        INSERT INTO orders (id, user_id, recipe, volume, status, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
    `
    _, err := r.db.Exec(ctx, query,
        order.ID,
        order.UserID,
        order.Recipe,
        order.Volume,
        order.Status,
        order.CreatedAt,
        order.UpdatedAt,
    )
    return err
}

// ... інші методи

// internal/usecase/order_usecase.go
package usecase

import (
    "context"
    "myapp/internal/domain"
    "myapp/internal/repository"
    "time"
    "github.com/google/uuid"
)

type OrderUseCase interface {
    GetOrder(ctx context.Context, id string) (domain.Order, error)
    CreateOrder(ctx context.Context, dto CreateOrderDTO) (domain.Order, error)
}

type CreateOrderDTO struct {
    UserID string
    Recipe string
    Volume string
}

type orderService struct {
    repo repository.OrderRepository
}

func NewOrderService(repo repository.OrderRepository) OrderUseCase {
    return &orderService{repo: repo}
}

func (s *orderService) GetOrder(ctx context.Context, id string) (domain.Order, error) {
    return s.repo.FindByID(ctx, id)
}

func (s *orderService) CreateOrder(ctx context.Context, dto CreateOrderDTO) (domain.Order, error) {
    // Бізнес-валідація
    if dto.Recipe == "" {
        return domain.Order{}, ErrInvalidRecipe
    }

    order := domain.Order{
        ID:        uuid.New().String(),
        UserID:    dto.UserID,
        Recipe:    dto.Recipe,
        Volume:    dto.Volume,
        Status:    domain.OrderStatusPending,
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }

    if err := s.repo.Create(ctx, &order); err != nil {
        return domain.Order{}, err
    }

    return order, nil
}

// internal/delivery/http/order_handler.go
package http

import (
    "encoding/json"
    "net/http"
    "myapp/internal/usecase"
    "github.com/go-chi/chi/v5"
)

type OrderHandler struct {
    useCase usecase.OrderUseCase
}

func NewOrderHandler(useCase usecase.OrderUseCase) *OrderHandler {
    return &OrderHandler{useCase: useCase}
}

func (h *OrderHandler) RegisterRoutes(r chi.Router) {
    r.Get("/orders/{id}", h.Get)
    r.Post("/orders", h.Create)
}

func (h *OrderHandler) Get(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")

    order, err := h.useCase.GetOrder(r.Context(), id)
    if err != nil {
        http.Error(w, "Order not found", http.StatusNotFound)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(order)
}

func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
    var req struct {
        UserID string `json:"user_id"`
        Recipe string `json:"recipe"`
        Volume string `json:"volume"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    dto := usecase.CreateOrderDTO{
        UserID: req.UserID,
        Recipe: req.Recipe,
        Volume: req.Volume,
    }

    order, err := h.useCase.CreateOrder(r.Context(), dto)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(order)
}

// cmd/server/main.go
package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "myapp/internal/delivery/http/handler"
    "myapp/internal/repository/postgres"
    "myapp/internal/usecase"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
    "github.com/jackc/pgx/v5/pgxpool"
)

func main() {
    // Підключення до бази даних
    dbURL := os.Getenv("DATABASE_URL")
    if dbURL == "" {
        log.Fatal("DATABASE_URL not set")
    }

    pool, err := pgxpool.New(context.Background(), dbURL)
    if err != nil {
        log.Fatalf("Unable to connect to database: %v", err)
    }
    defer pool.Close()

    // Ініціалізація шарів (Dependency Injection)
    orderRepo := postgres.NewOrderRepository(pool)
    orderUseCase := usecase.NewOrderService(orderRepo)
    orderHandler := handler.NewOrderHandler(orderUseCase)

    // Налаштування роутера
    r := chi.NewRouter()
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.RequestID)
    r.Use(middleware.Timeout(60 * time.Second))

    // Реєстрація маршрутів
    r.Get("/health", healthCheckHandler)
    r.Route("/v1", func(r chi.Router) {
        orderHandler.RegisterRoutes(r)
    })

    // Налаштування сервера з Graceful Shutdown
    srv := &http.Server{
        Addr:         ":8080",
        Handler:      r,
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    // Запуск сервера у горутині
    go func() {
        log.Printf("🚀 Server starting on %s", srv.Addr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    // Очікування сигналу завершення
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("⏳ Shutting down server...")

    // Graceful Shutdown з таймаутом 30 секунд
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }

    log.Println("✅ Server stopped gracefully")
}

func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status":"healthy","timestamp":"` + time.Now().Format(time.RFC3339) + `"}`))
}

// internal/delivery/http/order_handler_test.go
package http_test

import (
    "bytes"
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "myapp/internal/delivery/http/handler"
    "myapp/internal/domain"
    "myapp/internal/usecase"

    "github.com/go-chi/chi/v5"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

// Mock UseCase
type MockOrderUseCase struct {
    mock.Mock
}

func (m *MockOrderUseCase) GetOrder(ctx context.Context, id string) (domain.Order, error) {
    args := m.Called(ctx, id)
    return args.Get(0).(domain.Order), args.Error(1)
}

func (m *MockOrderUseCase) CreateOrder(ctx context.Context, dto usecase.CreateOrderDTO) (domain.Order, error) {
    args := m.Called(ctx, dto)
    return args.Get(0).(domain.Order), args.Error(1)
}

func TestOrderHandler_Get(t *testing.T) {
    // Arrange
    mockUseCase := new(MockOrderUseCase)
    h := handler.NewOrderHandler(mockUseCase)

    expectedOrder := domain.Order{
        ID:     "order_123",
        UserID: "user_456",
        Recipe: "espresso",
        Status: domain.OrderStatusCompleted,
    }

    mockUseCase.On("GetOrder", mock.Anything, "order_123").Return(expectedOrder, nil)

    // Створюємо запит
    req := httptest.NewRequest(http.MethodGet, "/orders/order_123", nil)
    rec := httptest.NewRecorder()

    // Налаштовуємо роутер з параметрами шляху
    r := chi.NewRouter()
    r.Get("/orders/{id}", h.Get)

    // Act
    r.ServeHTTP(rec, req)

    // Assert
    assert.Equal(t, http.StatusOK, rec.Code)
    
    var response domain.Order
    err := json.NewDecoder(rec.Body).Decode(&response)
    assert.NoError(t, err)
    assert.Equal(t, expectedOrder.ID, response.ID)
    assert.Equal(t, expectedOrder.Recipe, response.Recipe)

    mockUseCase.AssertExpectations(t)
}

func TestOrderHandler_Create(t *testing.T) {
    // Arrange
    mockUseCase := new(MockOrderUseCase)
    h := handler.NewOrderHandler(mockUseCase)

    requestBody := map[string]string{
        "user_id": "user_456",
        "recipe":  "cappuccino",
        "volume":  "200ml",
    }
    body, _ := json.Marshal(requestBody)

    expectedOrder := domain.Order{
        ID:     "order_789",
        UserID: "user_456",
        Recipe: "cappuccino",
        Status: domain.OrderStatusPending,
    }

    mockUseCase.On("CreateOrder", mock.Anything, mock.MatchedBy(func(dto usecase.CreateOrderDTO) bool {
        return dto.UserID == "user_456" && dto.Recipe == "cappuccino"
    })).Return(expectedOrder, nil)

    req := httptest.NewRequest(http.MethodPost, "/orders", bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    rec := httptest.NewRecorder()

    r := chi.NewRouter()
    r.Post("/orders", h.Create)

    // Act
    r.ServeHTTP(rec, req)

    // Assert
    assert.Equal(t, http.StatusCreated, rec.Code)
    
    var response domain.Order
    json.NewDecoder(rec.Body).Decode(&response)
    assert.Equal(t, expectedOrder.ID, response.ID)

    mockUseCase.AssertExpectations(t)
}