state-hub/api/routers/technical_debt.py

import uuid

from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from api.database import get_session
from api.models.domain import Domain
from api.models.technical_debt import TDStatus, TechnicalDebt
from api.schemas.technical_debt import TDCreate, TDRead, TDUpdate

router = APIRouter(prefix="/technical-debt", tags=["technical-debt"])


async def _resolve_domain_id(slug: str, session: AsyncSession) -> uuid.UUID:
    """Resolve a domain slug to its UUID, raising 422 if unknown."""
    row = await session.execute(
        select(Domain.id).where(Domain.slug == slug, Domain.status == "active")
    )
    domain_id = row.scalar_one_or_none()
    if domain_id is None:
        valid = [r[0] for r in (await session.execute(
            select(Domain.slug).where(Domain.status == "active")
        )).all()]
        raise HTTPException(
            status_code=422,
            detail=f"Unknown domain '{slug}'. Valid domains: {sorted(valid)}",
        )
    return domain_id


@router.get("/", response_model=list[TDRead])
async def list_td(
    domain: str | None = None,
    status: TDStatus | None = None,
    debt_type: str | None = None,
    severity: str | None = None,
    session: AsyncSession = Depends(get_session),
) -> list[TechnicalDebt]:
    q = select(TechnicalDebt)
    if domain:
        domain_id = await _resolve_domain_id(domain, session)
        q = q.where(TechnicalDebt.domain_id == domain_id)
    if status:
        q = q.where(TechnicalDebt.status == status)
    if debt_type:
        q = q.where(TechnicalDebt.debt_type == debt_type)
    if severity:
        q = q.where(TechnicalDebt.severity == severity)
    q = q.order_by(TechnicalDebt.created_at)
    result = await session.execute(q)
    return list(result.scalars().all())


@router.post("/", response_model=TDRead, status_code=status.HTTP_201_CREATED)
async def create_td(
    body: TDCreate,
    session: AsyncSession = Depends(get_session),
) -> TechnicalDebt:
    domain_id = await _resolve_domain_id(body.domain, session)
    data = body.model_dump(exclude={"domain"})
    data["domain_id"] = domain_id
    td = TechnicalDebt(**data)
    session.add(td)
    await session.commit()
    await session.refresh(td)
    return td


@router.get("/{td_id}", response_model=TDRead)
async def get_td(
    td_id: uuid.UUID,
    session: AsyncSession = Depends(get_session),
) -> TechnicalDebt:
    td = await session.get(TechnicalDebt, td_id)
    if td is None:
        raise HTTPException(status_code=404, detail="Technical debt item not found")
    return td


@router.patch("/{td_id}", response_model=TDRead)
async def update_td(
    td_id: uuid.UUID,
    body: TDUpdate,
    session: AsyncSession = Depends(get_session),
) -> TechnicalDebt:
    td = await session.get(TechnicalDebt, td_id)
    if td is None:
        raise HTTPException(status_code=404, detail="Technical debt item not found")
    for field, value in body.model_dump(exclude_unset=True).items():
        setattr(td, field, value)
    await session.commit()
    await session.refresh(td)
    return td


@router.delete("/{td_id}", response_model=TDRead)
async def defer_td(
    td_id: uuid.UUID,
    session: AsyncSession = Depends(get_session),
) -> TechnicalDebt:
    td = await session.get(TechnicalDebt, td_id)
    if td is None:
        raise HTTPException(status_code=404, detail="Technical debt item not found")
    td.status = TDStatus.deferred
    await session.commit()
    await session.refresh(td)
    return td