Auth, secretos y deploy

"""Configuración del proyecto. Todo viene del entorno; nada está hardcodeado.

Variables (prefijo INVENTARIO_):
  INVENTARIO_DB_URL      sqlite:///inventario.db | postgresql+psycopg://user:pass@host:5432/db
  INVENTARIO_ENV         dev | prod
  INVENTARIO_LOG_LEVEL   DEBUG | INFO | WARNING
  INVENTARIO_VERSION     sha del commit desplegado (lo pone el deploy)
"""

from functools import lru_cache

from pydantic_settings import BaseSettings, SettingsConfigDict


class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_prefix="INVENTARIO_", env_file=".env", extra="ignore")

    db_url: str = "sqlite:///inventario.db"
    env: str = "dev"
    log_level: str = "INFO"
    version: str = "dev"


@lru_cache
def get_settings() -> Settings:
    """Una sola instancia por proceso. En tests se limpia con get_settings.cache_clear()."""
    return Settings()

from inventario.settings import get_settings


@lru_cache
def get_engine() -> Engine:
    url = get_settings().db_url
    connect_args = {"check_same_thread": False} if url.startswith("sqlite") else {}
    return create_engine(url, connect_args=connect_args)

# Copia este archivo a .env y completa los valores. .env NUNCA se commitea.
INVENTARIO_DB_URL=sqlite:///inventario.db
INVENTARIO_ENV=dev
INVENTARIO_LOG_LEVEL=INFO

"""Logs en JSON, una línea por evento. Cloud Run los indexa solo (severity, message, campos)."""

import json
import logging
import sys
from datetime import UTC, datetime


class JsonFormatter(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        evento = {
            "time": datetime.now(UTC).isoformat(),
            "severity": record.levelname,
            "logger": record.name,
            "message": record.getMessage(),
        }
        # Campos extra pasados como logger.info("...", extra={"campos": {...}})
        campos = getattr(record, "campos", None)
        if campos:
            evento.update(campos)
        if record.exc_info:
            evento["exception"] = self.formatException(record.exc_info)
        return json.dumps(evento, ensure_ascii=False)


def configurar_logs(nivel: str = "INFO") -> None:
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(JsonFormatter())
    root = logging.getLogger()
    root.handlers = [handler]
    root.setLevel(nivel.upper())
    # uvicorn trae sus propios handlers; los alineamos para que todo salga en JSON
    for nombre in ("uvicorn", "uvicorn.error", "uvicorn.access"):
        logging.getLogger(nombre).handlers = []
        logging.getLogger(nombre).propagate = True

log = logging.getLogger("inventario.api")


@router.get("")
def listar(q: str = "", session: Session = Depends(get_db)) -> list[dict]:
    reactivos = services.buscar_reactivo(session, q)
    log.info("buscar reactivos", extra={"campos": {"q": q, "resultados": len(reactivos)}})
    return [r.model_dump() for r in reactivos]

class ApiKey(SQLModel, table=True):
    """Una llave por persona o sistema. Guardamos el hash, nunca la llave."""

    id: int | None = Field(default=None, primary_key=True)
    nombre: str = Field(unique=True, index=True)
    key_hash: str = Field(unique=True, index=True)
    activa: bool = True
    creada_en: datetime

"""API keys: se genera una vez, se guarda su hash, se compara el hash.

Si alguien se roba la base de datos no obtiene las llaves, solo sus huellas.
"""

import hashlib
import secrets
from datetime import UTC, datetime

from sqlmodel import Session, select

from inventario.models import ApiKey


def generar_key() -> str:
    return "inv_" + secrets.token_urlsafe(32)


def hash_key(key: str) -> str:
    return hashlib.sha256(key.encode()).hexdigest()


def crear_api_key(session: Session, nombre: str) -> tuple[ApiKey, str]:
    """Devuelve el registro y la llave EN CLARO. Es la única vez que se ve."""
    key = generar_key()
    registro = ApiKey(nombre=nombre, key_hash=hash_key(key), creada_en=datetime.now(UTC))
    session.add(registro)
    session.commit()
    session.refresh(registro)
    return registro, key


def validar_api_key(session: Session, key: str) -> ApiKey | None:
    registro = session.exec(select(ApiKey).where(ApiKey.key_hash == hash_key(key))).first()
    if registro is None or not registro.activa:
        return None
    return registro


def revocar_api_key(session: Session, nombre: str) -> bool:
    registro = session.exec(select(ApiKey).where(ApiKey.nombre == nombre)).first()
    if registro is None:
        return False
    registro.activa = False
    session.add(registro)
    session.commit()
    return True

keys = typer.Typer(help="Gestión de API keys")
app.add_typer(keys, name="keys")


@keys.command("create")
def keys_create(nombre: str) -> None:
    """Crea una llave y la muestra UNA vez. Guárdala en tu gestor de contraseñas."""
    with get_session() as session:
        _, key = crear_api_key(session, nombre)
    typer.echo(f"API key para {nombre} (no se volverá a mostrar):\n{key}")


@keys.command("revoke")
def keys_revoke(nombre: str) -> None:
    with get_session() as session:
        ok = revocar_api_key(session, nombre)
    if not ok:
        typer.echo(f"No existe la llave {nombre}", err=True)
        raise typer.Exit(1)
    typer.echo(f"Llave {nombre} revocada")

def require_api_key(
    x_api_key: str | None = Header(default=None),
    session: Session = Depends(get_db),
) -> ApiKey:
    """401 si falta la llave, no existe o está revocada. Un solo mensaje: no damos pistas."""
    if x_api_key is None:
        raise HTTPException(status_code=401, detail="Falta el header X-API-Key")
    registro = validar_api_key(session, x_api_key)
    if registro is None:
        raise HTTPException(status_code=401, detail="API key inválida o revocada")
    return registro

router = APIRouter(
    prefix="/reactivos", tags=["reactivos"], dependencies=[Depends(require_api_key)]
)

def test_health_es_publico(client):
    r = client.get("/health")
    assert r.status_code == 200


def test_sin_api_key_401(client):
    r = client.get("/reactivos")
    assert r.status_code == 401
    assert "X-API-Key" in r.json()["detail"]


def test_api_key_invalida_401(client):
    r = client.get("/reactivos", headers={"X-API-Key": "inv_invente-esta-llave"})
    assert r.status_code == 401


def test_api_key_valida_200(client, session, api_key):
    services.crear_reactivo(session, "Taq polimerasa", "µL")
    r = client.get("/reactivos", params={"q": "taq"}, headers={"X-API-Key": api_key})
    assert r.status_code == 200
    assert r.json()[0]["nombre"] == "Taq polimerasa"


def test_api_key_revocada_401(client, session, api_key):
    revocar_api_key(session, "tests")
    r = client.get("/reactivos", headers={"X-API-Key": api_key})
    assert r.status_code == 401

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: inventario
      POSTGRES_PASSWORD: solo-para-dev   # en prod esto vive en un gestor de secretos
      POSTGRES_DB: inventario
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U inventario"]
      interval: 2s
      timeout: 2s
      retries: 15

  api:
    build: .
    environment:
      INVENTARIO_DB_URL: postgresql+psycopg://inventario:solo-para-dev@db:5432/inventario
      INVENTARIO_ENV: dev
      INVENTARIO_LOG_LEVEL: INFO
    ports:
      - "8000:8000"
    depends_on:
      db:
        condition: service_healthy

volumes:
  pgdata:

name: deploy
on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: astral-sh/setup-uv@v6
      - run: uv sync
      - run: uv run ruff check .
      - run: uv run pytest

  deploy:
    needs: test            # sin verde no hay deploy
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write      # para autenticarse en GCP sin llaves guardadas
    steps:
      - uses: actions/checkout@v4
      - uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ vars.GCP_WIF_PROVIDER }}
          service_account: ${{ vars.GCP_SA_EMAIL }}
      - uses: google-github-actions/setup-gcloud@v2
      - run: |
          gcloud run deploy inventario-api \
            --source . \
            --region southamerica-east1 \
            --set-secrets INVENTARIO_DB_URL=inventario-db-url:latest \
            --set-env-vars INVENTARIO_ENV=prod,INVENTARIO_VERSION=${GITHUB_SHA::7}