xiaoxia-saas/apps/api/app/api/routes/workspaces.py

"""
Workspace API routes wired through the canonical API composition root.

Only the core create/list/detail endpoints are enabled here. Member invitation
and subscription endpoints remain in application use cases but are mounted only
after their persistence repositories are wired and smoke-tested.
"""

from app.auth import AuthenticatedUser, get_current_user
from app.dependencies import get_user_repository, get_workspace_member_repository, get_workspace_repository
from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel

from packages.application.workspace.create_workspace_use_case import CreateWorkspaceRequest, CreateWorkspaceUseCase
from packages.application.workspace.list_workspaces_use_case import (
    GetWorkspaceDetailRequest,
    GetWorkspaceDetailUseCase,
    ListWorkspacesRequest,
    ListWorkspacesUseCase,
)
from packages.ports.user_repository import UserRepository
from packages.ports.workspace_member_repository import WorkspaceMemberRepository
from packages.ports.workspace_repository import WorkspaceRepository

router = APIRouter(prefix="/workspaces", tags=["Workspaces"])


class CreateWorkspaceRequestModel(BaseModel):
    name: str
    subscription_plan: str = "free"


class WorkspaceResponseModel(BaseModel):
    workspace_id: str
    name: str
    subscription_plan: str
    max_projects: int
    max_storage_gb: int


class WorkspaceSummaryModel(BaseModel):
    workspace_id: str
    name: str
    subscription_plan: str
    max_projects: int
    max_storage_gb: int
    member_count: int
    user_role: str


class WorkspaceListResponseModel(BaseModel):
    workspaces: list[WorkspaceSummaryModel]


class WorkspaceDetailResponseModel(BaseModel):
    workspace_id: str
    name: str
    owner_user_id: str
    subscription_plan: str
    subscription_status: str
    max_projects: int
    max_storage_gb: int
    used_storage_gb: float
    member_count: int
    user_role: str


@router.post("", response_model=WorkspaceResponseModel, status_code=status.HTTP_201_CREATED)
async def create_workspace(
    request: CreateWorkspaceRequestModel,
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    workspace_repository: WorkspaceRepository = Depends(get_workspace_repository),
    workspace_member_repository: WorkspaceMemberRepository = Depends(get_workspace_member_repository),
    user_repository: UserRepository = Depends(get_user_repository),
):
    use_case = CreateWorkspaceUseCase(
        workspace_repository=workspace_repository,
        workspace_member_repository=workspace_member_repository,
        user_repository=user_repository,
    )
    response, error = use_case.execute(
        CreateWorkspaceRequest(
            name=request.name,
            owner_user_id=authenticated_user.user.id,
            subscription_plan=request.subscription_plan,
        )
    )
    if error or response is None:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=error or "Failed to create workspace")

    return WorkspaceResponseModel(
        workspace_id=response.workspace_id,
        name=response.name,
        subscription_plan=response.subscription_plan,
        max_projects=response.max_projects,
        max_storage_gb=response.max_storage_gb,
    )


@router.get("", response_model=WorkspaceListResponseModel)
async def list_workspaces(
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    workspace_repository: WorkspaceRepository = Depends(get_workspace_repository),
    workspace_member_repository: WorkspaceMemberRepository = Depends(get_workspace_member_repository),
):
    use_case = ListWorkspacesUseCase(
        workspace_repository=workspace_repository,
        workspace_member_repository=workspace_member_repository,
    )
    response, error = use_case.execute(ListWorkspacesRequest(user_id=authenticated_user.user.id))
    if error or response is None:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=error or "Failed to list workspaces")

    return WorkspaceListResponseModel(
        workspaces=[
            WorkspaceSummaryModel(
                workspace_id=workspace.workspace_id,
                name=workspace.name,
                subscription_plan=workspace.subscription_plan,
                max_projects=workspace.max_projects,
                max_storage_gb=workspace.max_storage_gb,
                member_count=workspace.member_count,
                user_role=workspace.user_role,
            )
            for workspace in response.workspaces
        ]
    )


@router.get("/{workspace_id}", response_model=WorkspaceDetailResponseModel)
async def get_workspace_detail(
    workspace_id: str,
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    workspace_repository: WorkspaceRepository = Depends(get_workspace_repository),
    workspace_member_repository: WorkspaceMemberRepository = Depends(get_workspace_member_repository),
):
    use_case = GetWorkspaceDetailUseCase(
        workspace_repository=workspace_repository,
        workspace_member_repository=workspace_member_repository,
    )
    detail, error = use_case.execute(
        GetWorkspaceDetailRequest(workspace_id=workspace_id, user_id=authenticated_user.user.id)
    )
    if error or detail is None:
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=error or "Workspace access denied")

    return WorkspaceDetailResponseModel(
        workspace_id=detail.workspace_id,
        name=detail.name,
        owner_user_id=detail.owner_user_id,
        subscription_plan=detail.subscription_plan,
        subscription_status=detail.subscription_status,
        max_projects=detail.max_projects,
        max_storage_gb=detail.max_storage_gb,
        used_storage_gb=detail.used_storage_gb,
        member_count=detail.member_count,
        user_role=detail.user_role,
    )