kami_spider_monorepo/apps/app_a/router.py

"""
App A Router - API endpoints for user management.
"""

from fastapi import APIRouter, Depends, Request
from sqlalchemy.ext.asyncio import AsyncSession
from core.database import get_session
from core.responses import ApiResponse, success, paginated, ERROR_RESPONSES
from core.dependencies import get_trace_id
from apps.app_a.schemas import UserCreate, UserUpdate, UserResponse
from apps.app_a.services import UserService

router = APIRouter(
    prefix="/app-a",
    tags=["App A - Users"]
)


@router.post(
    "/users",
    response_model=ApiResponse[UserResponse],
    status_code=201,
    summary="Create a new user",
    description="Create a new user with username, email, and password",
    responses={
        201: {"description": "User created successfully"},
        400: ERROR_RESPONSES[400],
        409: ERROR_RESPONSES[409],
        422: ERROR_RESPONSES[422],
        500: ERROR_RESPONSES[500],
    }
)
async def create_user(
    user_data: UserCreate,
    session: AsyncSession = Depends(get_session),
    trace_id: str = Depends(get_trace_id)
) -> ApiResponse[UserResponse]:
    """Create a new user."""
    user = await UserService.create_user(session, user_data)
    user_response = UserResponse.model_validate(user)
    return success(data=user_response, message="User created successfully", trace_id=trace_id)


@router.get(
    "/users/{user_id}",
    response_model=ApiResponse[UserResponse],
    summary="Get user by ID",
    description="Retrieve a user by their ID",
    responses={
        200: {"description": "User retrieved successfully"},
        404: ERROR_RESPONSES[404],
        500: ERROR_RESPONSES[500],
    }
)
async def get_user(
    user_id: int,
    session: AsyncSession = Depends(get_session),
    trace_id: str = Depends(get_trace_id)
) -> ApiResponse[UserResponse]:
    """Get user by ID."""
    user = await UserService.get_user(session, user_id)
    user_response = UserResponse.model_validate(user)
    return success(data=user_response, trace_id=trace_id)


@router.get(
    "/users",
    response_model=ApiResponse,
    summary="List all users",
    description="List all users with pagination support",
    responses={
        200: {"description": "Users retrieved successfully"},
        400: ERROR_RESPONSES[400],
        500: ERROR_RESPONSES[500],
    }
)
async def list_users(
    page: int = 1,
    page_size: int = 10,
    session: AsyncSession = Depends(get_session),
    trace_id: str = Depends(get_trace_id)
) -> ApiResponse:
    """List all users with pagination."""
    skip = (page - 1) * page_size
    users, total = await UserService.list_users(session, skip, page_size)
    user_responses = [UserResponse.model_validate(user) for user in users]
    return paginated(
        items=user_responses,
        total=total,
        page=page,
        page_size=page_size,
        trace_id=trace_id
    )


@router.put(
    "/users/{user_id}",
    response_model=ApiResponse[UserResponse],
    summary="Update user",
    description="Update user information",
    responses={
        200: {"description": "User updated successfully"},
        400: ERROR_RESPONSES[400],
        404: ERROR_RESPONSES[404],
        422: ERROR_RESPONSES[422],
        500: ERROR_RESPONSES[500],
    }
)
async def update_user(
    user_id: int,
    user_data: UserUpdate,
    session: AsyncSession = Depends(get_session),
    trace_id: str = Depends(get_trace_id)
) -> ApiResponse[UserResponse]:
    """Update user."""
    user = await UserService.update_user(session, user_id, user_data)
    user_response = UserResponse.model_validate(user)
    return success(data=user_response, message="User updated successfully", trace_id=trace_id)


@router.delete(
    "/users/{user_id}",
    response_model=ApiResponse[None],
    summary="Delete user",
    description="Delete a user by ID",
    responses={
        200: {"description": "User deleted successfully"},
        404: ERROR_RESPONSES[404],
        500: ERROR_RESPONSES[500],
    }
)
async def delete_user(
    user_id: int,
    session: AsyncSession = Depends(get_session),
    trace_id: str = Depends(get_trace_id)
) -> ApiResponse[None]:
    """Delete user."""
    await UserService.delete_user(session, user_id)
    return success(data=None, message="User deleted successfully", trace_id=trace_id)