Newer
Older
gnexus-book / server / app / auth / routes.py
from __future__ import annotations

from datetime import UTC, datetime
from typing import Any

from fastapi import APIRouter, Depends, HTTPException, Query, Request
from fastapi.responses import JSONResponse, RedirectResponse
from gnexus_gauth.exceptions import WebhookPayloadException, WebhookVerificationException
from pydantic import BaseModel

from ..config import Settings, get_settings
from ..storage.db import Database
from .service import AuthError, AuthService
from .sessions import SUPPORTED_LOCALES, revoke_session, set_user_locale
from .users import serialize_user
from .webhooks import handle_webhook_event

router = APIRouter()


class MeUpdate(BaseModel):
    locale: str | None = None


def get_auth_service(
    settings: Settings = Depends(get_settings),
) -> AuthService | None:
    if not settings.auth_enabled:
        return None
    return AuthService(settings, Database.from_settings(settings))


def _me_payload(request: Request, settings: Settings) -> dict[str, Any]:
    user = getattr(request.state, "user", None)
    return {
        "auth_enabled": settings.auth_enabled,
        "user": serialize_user(user) if user else None,
        "locale": user.locale if user else None,
        "locale_effective": user.effective_locale if user else "en",
    }


def _safe_return_to(value: str | None) -> str | None:
    if not value or not value.startswith("/") or value.startswith("//"):
        return None
    return value


@router.get("/me")
def me(request: Request, settings: Settings = Depends(get_settings)) -> dict[str, Any]:
    return _me_payload(request, settings)


@router.patch("/me")
def update_me(
    payload: MeUpdate,
    request: Request,
    settings: Settings = Depends(get_settings),
) -> dict[str, Any]:
    if not settings.auth_enabled:
        raise HTTPException(status_code=400, detail="Authentication is not configured")
    user = getattr(request.state, "user", None)
    if user is None:
        raise HTTPException(status_code=401, detail="Not authenticated")
    if payload.locale not in {None, "", *SUPPORTED_LOCALES}:
        raise HTTPException(status_code=400, detail="locale must be en, uk, ru, or empty")

    updated = set_user_locale(
        Database.from_settings(settings), user.id, payload.locale or None
    )
    return {
        "auth_enabled": True,
        "user": serialize_user(updated),
        "locale": updated.locale,
        "locale_effective": updated.effective_locale,
    }


@router.get("/auth/login")
def auth_login(
    return_to: str | None = Query(default=None),
    settings: Settings = Depends(get_settings),
    service: AuthService | None = Depends(get_auth_service),
) -> RedirectResponse:
    if service is None:
        raise HTTPException(status_code=400, detail="Authentication is not configured")
    url = service.build_login_url(return_to=_safe_return_to(return_to))
    return RedirectResponse(url, status_code=303)


@router.get("/auth/callback")
def auth_callback(
    request: Request,
    code: str | None = Query(default=None),
    state: str | None = Query(default=None),
    error: str | None = Query(default=None),
    settings: Settings = Depends(get_settings),
    service: AuthService | None = Depends(get_auth_service),
) -> RedirectResponse:
    if service is None:
        raise HTTPException(status_code=400, detail="Authentication is not configured")
    if error:
        return RedirectResponse("/?auth_error=access_denied", status_code=303)
    if not code or not state:
        raise HTTPException(status_code=400, detail="Missing code or state")

    try:
        _, token, expires_at = service.exchange_code(
            code,
            state,
            user_agent=request.headers.get("user-agent"),
            ip_address=request.client.host if request.client else None,
        )
    except AuthError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc
    except Exception as exc:
        raise HTTPException(status_code=400, detail="Authentication failed") from exc

    response = RedirectResponse("/", status_code=303)
    max_age = max(0, int((expires_at - datetime.now(UTC)).total_seconds()))
    response.set_cookie(
        key=settings.auth_session_cookie,
        value=token,
        max_age=max_age,
        httponly=True,
        secure=settings.auth_cookie_secure,
        samesite="lax",
        path="/",
    )
    return response


@router.post("/auth/logout")
def auth_logout(
    request: Request, settings: Settings = Depends(get_settings)
) -> JSONResponse:
    token = request.cookies.get(settings.auth_session_cookie)
    if token:
        revoke_session(Database.from_settings(settings), token)
    response = JSONResponse({"status": "ok"})
    response.delete_cookie(settings.auth_session_cookie, path="/")
    return response


@router.post("/webhooks/gnexus-auth")
@router.post("/webhooks/gnexus-auth/")
async def gnexus_auth_webhook(
    request: Request, settings: Settings = Depends(get_settings)
) -> dict[str, Any]:
    if not settings.auth_enabled or not settings.auth_webhook_secret:
        raise HTTPException(status_code=503, detail="Webhook endpoint is not configured")

    raw_bytes = await request.body()
    try:
        raw_body = raw_bytes.decode("utf-8")
    except UnicodeDecodeError as exc:
        raise HTTPException(status_code=400, detail="Invalid webhook payload") from exc

    service = AuthService(settings, Database.from_settings(settings))
    try:
        event = service.verify_and_parse_webhook(raw_body, dict(request.headers))
    except WebhookVerificationException as exc:
        raise HTTPException(status_code=401, detail="Invalid webhook signature") from exc
    except WebhookPayloadException as exc:
        raise HTTPException(status_code=400, detail="Invalid webhook payload") from exc

    processed = handle_webhook_event(Database.from_settings(settings), event)
    return {"status": "ok", "event_id": event.event_id, "duplicate": not processed}