HTTP Utilities

from fastapi import FastAPI, Depends
from fastkit_core.http import (
    success_response, paginated_response,
    NotFoundException,
    register_exception_handlers,
    RequestIDMiddleware, LocaleMiddleware,
    get_pagination
)

app = FastAPI()

# 1. Register exception handlers (before routes)
register_exception_handlers(app)

# 2. Add middleware
app.add_middleware(LocaleMiddleware)
app.add_middleware(RequestIDMiddleware)

# 3. Use in routes
@app.get("/users/{user_id}")
def get_user(user_id: int):
    user = service.find(user_id)
    if not user:
        raise NotFoundException("User not found")   # auto-formatted
    return success_response(data=user.to_dict())

@app.get("/users")
def list_users(pagination: dict = Depends(get_pagination)):
    users, meta = service.paginate(**pagination)
    return paginated_response(items=[u.to_dict() for u in users], pagination=meta)

from fastkit_core.http import (
    NotFoundException,
    ValidationException,
    UnauthorizedException,
    ForbiddenException,
    FastKitException,
)

# 404 — record missing
raise NotFoundException("User not found")

# 422 — business rule
raise ValidationException(
    errors={"email": ["Email already registered"]},
    message="Validation failed"
)

# 401 — auth failure
raise UnauthorizedException("Token expired")

# 403 — permission
raise ForbiddenException("Admin access required")

# Custom status code
raise FastKitException("Payment required", status_code=402)

# With field errors on any exception
raise FastKitException(
    message="Operation failed",
    status_code=400,
    errors={"balance": ["Insufficient funds"]}
)

from fastkit_core.http import FastKitException

class PaymentRequiredException(FastKitException):
    def __init__(self, message: str = "Payment required"):
        super().__init__(message, status_code=402)

class RateLimitException(FastKitException):
    def __init__(self, retry_after: int = 60):
        super().__init__(
            f"Too many requests. Retry after {retry_after}s",
            status_code=429
        )

# Usage
raise PaymentRequiredException("Subscribe to access this feature")
raise RateLimitException(retry_after=30)

from fastapi import FastAPI
from fastkit_core.http import register_exception_handlers

app = FastAPI()
register_exception_handlers(app)   # ← register BEFORE routes

@app.get("/users/{user_id}")
def get_user(user_id: int): ...

# config/app.py
DEBUG = True   # development — shows actual error message
DEBUG = False  # production  — hides details, returns "Internal server error"

from fastapi import Depends
from fastkit_core.http import get_pagination, paginated_response

@app.get("/products")
def list_products(pagination: dict = Depends(get_pagination)):
    # ?page=2&per_page=50
    # pagination = {'page': 2, 'per_page': 50, 'offset': 50}

    products, meta = service.paginate(
        page=pagination['page'],
        per_page=pagination['per_page']
    )
    return paginated_response(items=[p.to_dict() for p in products], pagination=meta)

from fastkit_core.http import get_locale as locale_dep
from fastkit_core.i18n import _

@app.get("/greeting")
def greeting(locale: str = Depends(locale_dep)):
    return {
        "locale": locale,
        "message": _('messages.hello')
    }

# GET /greeting?locale=es  →  locale = "es"
# GET /greeting            →  locale from context (set by LocaleMiddleware)

from fastapi import FastAPI, Depends
from fastkit_core.http import (
    success_response, paginated_response,
    NotFoundException, ValidationException, ForbiddenException,
    register_exception_handlers,
    RequestIDMiddleware, LocaleMiddleware,
    get_pagination,
)
from fastkit_core.i18n import _

app = FastAPI(title="My FastKit API")

# ── Setup (order matters) ─────────────────────────
register_exception_handlers(app)     # exception handling

app.add_middleware(LocaleMiddleware)      # locale detection
app.add_middleware(RequestIDMiddleware)   # request ID (runs first)

# ── Routes ────────────────────────────────────────
@app.get("/")
def root():
    return success_response(
        data={"version": "1.0.0"},
        message=_('messages.welcome')
    )

@app.get("/users/{user_id}")
def get_user(user_id: int):
    user = service.find(user_id)
    if not user:
        raise NotFoundException(_('errors.user_not_found'))
    return success_response(data=user.to_dict())

@app.get("/users")
def list_users(pagination: dict = Depends(get_pagination)):
    users, meta = service.paginate(**pagination)
    return paginated_response(
        items=[u.to_dict() for u in users],
        pagination=meta
    )

@app.post("/users", status_code=201)
def create_user(data: UserCreate, current_user = Depends(get_current_user)):
    if not current_user.can_create_users:
        raise ForbiddenException("Insufficient permissions")

    # Service validation errors bubble up automatically
    user = service.create(data)
    return success_response(
        data=user.model_dump(),
        message=_('messages.user_created'),
        status_code=201
    )

@app.delete("/users/{user_id}", status_code=204)
def delete_user(user_id: int, current_user = Depends(get_current_user)):
    if not current_user.is_admin:
        raise ForbiddenException("Admin access required")
    service.delete(user_id)