agent-platform/services/auth-service/app/api/routes.py

from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import text
from sqlalchemy.orm import Session

from core_domain import ServiceHealth

from app.application.services import AuthApplicationService
from app.db.session import get_db
from app.domain.repositories import RoleAssignmentRepository, RoleRepository, UserRepository
from app.schemas.auth import (
    PermissionCheckRequest,
    PermissionCheckResponse,
    RoleAssignmentCreateRequest,
    RoleAssignmentResponse,
    RoleAssignmentStatusUpdateRequest,
    RoleCreateRequest,
    RoleResponse,
    RoleStatusUpdateRequest,
    UserCreateRequest,
    UserResponse,
    UserStatusUpdateRequest,
)

router = APIRouter()


def get_auth_application_service(db: Session = Depends(get_db)) -> AuthApplicationService:
    return AuthApplicationService(
        user_repository=UserRepository(db),
        role_repository=RoleRepository(db),
        assignment_repository=RoleAssignmentRepository(db),
    )


@router.get("/health", response_model=ServiceHealth)
def health_check(db: Session = Depends(get_db)) -> ServiceHealth:
    db.execute(text("SELECT 1"))
    return ServiceHealth(service="auth-service", status="ok", database="ok")


@router.post("/users", response_model=UserResponse)
def create_user(
    payload: UserCreateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> UserResponse:
    return UserResponse.from_entity(service.create_user(payload))


@router.get("/users", response_model=list[UserResponse])
def list_users(
    tenant_id: str = Query(...),
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> list[UserResponse]:
    return [UserResponse.from_entity(item) for item in service.list_users(tenant_id=tenant_id)]


@router.patch("/users/{user_id}/status", response_model=UserResponse)
def update_user_status(
    user_id: str,
    payload: UserStatusUpdateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> UserResponse:
    entity = service.update_user_status(user_id=user_id, payload=payload)
    if entity is None:
        raise HTTPException(status_code=404, detail=f"user not found: {user_id}")
    return UserResponse.from_entity(entity)


@router.post("/roles", response_model=RoleResponse)
def create_role(
    payload: RoleCreateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> RoleResponse:
    return RoleResponse.from_entity(service.create_role(payload))


@router.get("/roles", response_model=list[RoleResponse])
def list_roles(
    tenant_id: str = Query(...),
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> list[RoleResponse]:
    return [RoleResponse.from_entity(item) for item in service.list_roles(tenant_id=tenant_id)]


@router.patch("/roles/{role_id}/status", response_model=RoleResponse)
def update_role_status(
    role_id: str,
    payload: RoleStatusUpdateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> RoleResponse:
    entity = service.update_role_status(role_id=role_id, payload=payload)
    if entity is None:
        raise HTTPException(status_code=404, detail=f"role not found: {role_id}")
    return RoleResponse.from_entity(entity)


@router.post("/assignments", response_model=RoleAssignmentResponse)
def create_assignment(
    payload: RoleAssignmentCreateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> RoleAssignmentResponse:
    return RoleAssignmentResponse.from_entity(service.create_assignment(payload))


@router.get("/assignments", response_model=list[RoleAssignmentResponse])
def list_assignments(
    tenant_id: str = Query(...),
    user_id: str = Query(...),
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> list[RoleAssignmentResponse]:
    return [
        RoleAssignmentResponse.from_entity(item)
        for item in service.list_assignments(tenant_id=tenant_id, user_id=user_id)
    ]


@router.patch("/assignments/{assignment_id}/status", response_model=RoleAssignmentResponse)
def update_assignment_status(
    assignment_id: str,
    payload: RoleAssignmentStatusUpdateRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> RoleAssignmentResponse:
    entity = service.update_assignment_status(assignment_id=assignment_id, payload=payload)
    if entity is None:
        raise HTTPException(status_code=404, detail=f"assignment not found: {assignment_id}")
    return RoleAssignmentResponse.from_entity(entity)


@router.post("/permissions/check", response_model=PermissionCheckResponse)
def check_permission(
    payload: PermissionCheckRequest,
    service: AuthApplicationService = Depends(get_auth_application_service),
) -> PermissionCheckResponse:
    return service.check_permission(payload)