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 _get_valid_domain_slugs(session: AsyncSession) -> set[str]:
    """Return the set of active domain slugs from the DB."""
    rows = await session.execute(select(Domain.slug).where(Domain.status == "active"))
    return {r[0] for r in rows.all()}


@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:
        q = q.where(TechnicalDebt.domain == domain)
    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:
    valid_domains = await _get_valid_domain_slugs(session)
    if body.domain not in valid_domains:
        raise HTTPException(
            status_code=422,
            detail=f"Unknown domain '{body.domain}'. Valid domains: {sorted(valid_domains)}",
        )
    td = TechnicalDebt(**body.model_dump())
    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