teecup/app/routers/auth.py

"""
Autentisering: magic-link-forespørsel/-verifisering, utlogging, "hvem er jeg".

Sikkerhetsmønster (se plan/ADR-009):
  - request-link svarer ALLTID identisk, uansett om e-posten finnes eller
    nettopp fikk en lenke -- unngår at endepunktet kan brukes til å sjekke
    hvilke e-poster som har konto (enumerering).
  - Kun SHA-256-hashen av token lagres, aldri klarteksten.
  - app_user opprettes FØRST når en gyldig, uforbrukt token løses inn i
    verify-link -- IKKE når lenken bare forespørres (hindrer massopprettelse
    av kontoer for e-poster man ikke eier).
  - Token-forbruk er ÉN atomisk UPDATE ... RETURNING (ikke les-sjekk-skriv)
    for å hindre at to samtidige forsøk med samme lenke begge lykkes.
  - Dev-modus: siden ingen ekte SMTP-oppsett finnes for TeeCup ennå, logges
    rå token server-side i stedet for å sendes på e-post -- KUN når
    settings.DEV_LOG_MAGIC_LINKS er eksplisitt satt (aldri på som standard).
    # TODO: erstatt med ekte SMTP-utsending før produksjon.
"""

import hashlib
import secrets
from datetime import datetime, timedelta, timezone

from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
from pydantic import BaseModel, EmailStr

from ..auth import CurrentUser, SESSION_COOKIE_NAME, create_session_token, get_current_user, should_use_secure_cookies
from ..config import settings
from ..db import plain_connection

router = APIRouter(prefix="/auth", tags=["auth"])

_GENERIC_RESPONSE = {
    "status": "ok",
    "detail": "Hvis e-posten er gyldig, er en innloggingslenke sendt.",
}


def _hash_token(token: str) -> str:
    return hashlib.sha256(token.encode("utf-8")).hexdigest()


class MagicLinkRequest(BaseModel):
    email: EmailStr


@router.post("/request-link")
async def request_magic_link(body: MagicLinkRequest) -> dict:
    email = body.email.lower()
    now = datetime.now(timezone.utc)
    cooldown_cutoff = now - timedelta(seconds=settings.MAGIC_LINK_COOLDOWN_SECONDS)

    async with plain_connection() as conn:
        recent = await conn.fetchval(
            """
            SELECT EXISTS (
                SELECT 1 FROM magic_link_token
                WHERE email = $1 AND consumed_at IS NULL AND created_at > $2
            )
            """,
            email,
            cooldown_cutoff,
        )
        if not recent:
            # Ugyldiggjør tidligere uforbrukte lenker for denne e-posten --
            # begrenser vinduet en eldre, lekket lenke kan misbrukes i.
            await conn.execute(
                "UPDATE magic_link_token SET consumed_at = now() WHERE email = $1 AND consumed_at IS NULL",
                email,
            )
            raw_token = secrets.token_urlsafe(32)
            expires_at = now + timedelta(minutes=settings.MAGIC_LINK_MAX_AGE_MINUTES)
            await conn.execute(
                "INSERT INTO magic_link_token (email, token_hash, expires_at) VALUES ($1, $2, $3)",
                email,
                _hash_token(raw_token),
                expires_at,
            )
            if settings.DEV_LOG_MAGIC_LINKS:
                print(f"[DEV] Magic link for {email}: {raw_token}", flush=True)

    return _GENERIC_RESPONSE


class MagicLinkVerify(BaseModel):
    token: str
    display_name: str | None = None


class SessionUser(BaseModel):
    id: str
    email: str
    display_name: str


@router.post("/verify-link", response_model=SessionUser)
async def verify_magic_link(
    body: MagicLinkVerify, response: Response, request: Request
) -> SessionUser:
    token_hash = _hash_token(body.token)
    async with plain_connection() as conn:
        # Atomisk forbruk: ÉN setning, ikke les-så-sjekk-så-skriv -- to
        # samtidige forsøk med samme lenke kan da ikke begge lykkes.
        email = await conn.fetchval(
            """
            UPDATE magic_link_token
            SET consumed_at = now()
            WHERE token_hash = $1 AND consumed_at IS NULL AND expires_at > now()
            RETURNING email
            """,
            token_hash,
        )
        if email is None:
            raise HTTPException(
                status.HTTP_401_UNAUTHORIZED, detail="Lenken er ugyldig, brukt eller utløpt."
            )

        placeholder_name = email.split("@")[0]
        user_id = await conn.fetchval(
            """
            INSERT INTO app_user (email, display_name)
            VALUES ($1, $2)
            ON CONFLICT (email) WHERE email IS NOT NULL DO NOTHING
            RETURNING id
            """,
            email,
            body.display_name or placeholder_name,
        )
        if user_id is None:
            # En annen samtidig verifisering for samme e-post vant innsettingen.
            user_id = await conn.fetchval("SELECT id FROM app_user WHERE email = $1", email)

        user_row = await conn.fetchrow(
            "SELECT id::text AS id, email::text AS email, display_name FROM app_user WHERE id = $1",
            user_id,
        )

    token = create_session_token(user_row["id"])
    response.set_cookie(
        SESSION_COOKIE_NAME,
        token,
        max_age=settings.SESSION_MAX_AGE_SECONDS,
        httponly=True,
        samesite="lax",
        secure=should_use_secure_cookies(request),
        path="/",
    )
    return SessionUser(**dict(user_row))


@router.post("/logout")
async def logout(response: Response) -> dict:
    response.delete_cookie(SESSION_COOKIE_NAME, path="/")
    return {"status": "ok"}


class MyOrg(BaseModel):
    organization_id: str
    role: str


class Me(BaseModel):
    id: str
    email: str
    display_name: str
    organizations: list[MyOrg]


@router.get("/me", response_model=Me)
async def me(user: CurrentUser = Depends(get_current_user)) -> Me:
    # MERK: henter bevisst IKKE organisasjonens navn her. Det ville krevd å
    # spørre `organization`-tabellen (som HAR RLS, org_self-policyen) via
    # plain_connection() -- altså UTEN org-kontekst satt. Under scratch-
    # testing avdekket dette en reell, dypere bug: org_self sin
    # `current_setting('app.current_org', true)::uuid` håndterer NULL trygt,
    # men IKKE tomstreng (som en custom GUC kan lese tilbake som på en
    # gjenbrukt pool-tilkobling der en annen forespørsel tidligere satte den
    # via SET LOCAL) -- det gir en 500 i stedet for skjemaets lovede "trygg
    # standard: se ingenting". Dette er en tverrgående RLS-sak (berører alle
    # 15 policyer i skjemaet, ikke noe auth-spesifikt) som fortjener sin egen
    # fokuserte rettingsrunde, ikke en hastefiks her. Se FEATURE_BACKLOG.md.
    async with plain_connection() as conn:
        user_row = await conn.fetchrow(
            "SELECT id::text AS id, email::text AS email, display_name FROM app_user WHERE id = $1",
            user.user_id,
        )
        org_rows = await conn.fetch(
            """
            SELECT organization_id::text AS organization_id, role
            FROM organization_membership
            WHERE user_id = $1
            """,
            user.user_id,
        )
    return Me(
        id=user_row["id"],
        email=user_row["email"],
        display_name=user_row["display_name"],
        organizations=[MyOrg(**dict(r)) for r in org_rows],
    )