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

import hashlib
import secrets
from dataclasses import dataclass, replace
from datetime import datetime, timedelta
from typing import Any
from uuid import UUID

from sqlalchemy import select, update

from ..storage.db import Database
from ..storage.models import User, UserSession, utcnow

SUPPORTED_LOCALES = {"en", "uk", "ru"}


@dataclass(frozen=True)
class CurrentUser:
    id: UUID
    sub: str
    email: str | None
    display_name: str | None
    profile: dict[str, Any]
    locale: str | None
    system_role: str | None
    status: str | None
    client_roles: tuple[str, ...]
    permissions: tuple[str, ...]
    blocked_at: datetime | None

    @property
    def is_blocked(self) -> bool:
        return self.blocked_at is not None

    @property
    def effective_locale(self) -> str:
        candidate = self.locale or self.profile.get("locale") or "en"
        normalized = str(candidate).split("-", 1)[0].lower()
        return normalized if normalized in SUPPORTED_LOCALES else "en"


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


def to_current_user(user: User) -> CurrentUser:
    return CurrentUser(
        id=user.id,
        sub=user.sub,
        email=user.email,
        display_name=user.display_name,
        profile=dict(user.profile or {}),
        locale=user.locale,
        system_role=user.system_role,
        status=user.status,
        client_roles=tuple(user.client_roles or []),
        permissions=tuple(user.permissions or []),
        blocked_at=user.blocked_at,
    )


def create_session(
    database: Database,
    user_id: UUID,
    ttl_seconds: int,
    user_agent: str | None = None,
    ip_address: str | None = None,
) -> tuple[str, datetime]:
    token = secrets.token_urlsafe(32)
    now = utcnow()
    expires_at = now + timedelta(seconds=ttl_seconds)
    with database.session() as session:
        with session.begin():
            session.add(
                UserSession(
                    user_id=user_id,
                    token_hash=token_hash(token),
                    created_at=now,
                    expires_at=expires_at,
                    user_agent=user_agent,
                    ip_address=ip_address,
                )
            )
    return token, expires_at


def resolve_session(database: Database, token: str) -> CurrentUser | None:
    now = utcnow()
    with database.session() as session:
        row = session.scalars(
            select(UserSession).where(UserSession.token_hash == token_hash(token))
        ).first()
        if row is None or row.revoked_at is not None or row.expires_at <= now:
            return None

        user = session.get(User, row.user_id)
        if user is None or user.blocked_at is not None:
            return None

        row.last_used_at = now
        session.commit()
        return to_current_user(user)


def revoke_session(database: Database, token: str) -> None:
    with database.session() as session:
        with session.begin():
            session.execute(
                update(UserSession)
                .where(
                    UserSession.token_hash == token_hash(token),
                    UserSession.revoked_at.is_(None),
                )
                .values(revoked_at=utcnow())
            )


def revoke_user_sessions(database: Database, user_id: UUID) -> None:
    with database.session() as session:
        with session.begin():
            session.execute(
                update(UserSession)
                .where(
                    UserSession.user_id == user_id,
                    UserSession.revoked_at.is_(None),
                )
                .values(revoked_at=utcnow())
            )


def set_user_locale(database: Database, user_id: UUID, locale: str | None) -> CurrentUser:
    normalized = locale or None
    if normalized is not None and normalized not in SUPPORTED_LOCALES:
        raise ValueError("locale must be en, uk, ru, or empty")

    with database.session() as session:
        with session.begin():
            user = session.get(User, user_id)
            if user is None:
                raise ValueError("User not found")
            user.locale = normalized
            session.flush()
            return to_current_user(user)


def with_locale(user: CurrentUser, locale: str | None) -> CurrentUser:
    return replace(user, locale=locale or None)