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

from core_domain import ServiceHealth
from core_dsl import EdgeDefinition, NodeDefinition, WorkflowDefinition
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import text
from sqlalchemy.orm import Session

from app.application.services import WorkflowApplicationService
from app.db.session import get_db
from app.domain.repositories import (
    AppDefinitionRepository,
    AppConfigRepository,
    WorkflowDefinitionRepository,
    WorkflowConfigRepository,
)
from app.schemas.app import (
    AppCreateRequest,
    AppListRequest,
    AppResponse,
    AppConfigCreateRequest,
    AppConfigListRequest,
    AppConfigResponse,
)
from app.schemas.workflow import (
    WorkflowCreateRequest,
    WorkflowDebuggerPlanRequest,
    WorkflowDebuggerPlanResponse,
    WorkflowDefinitionResponse,
    WorkflowDesignerValidateRequest,
    WorkflowDesignerValidateResponse,
    WorkflowListRequest,
    WorkflowConfigCreateRequest,
    WorkflowConfigDebuggerPlanRequest,
    WorkflowConfigDetailRequest,
    WorkflowConfigListRequest,
    WorkflowConfigResponse,
)

router = APIRouter()


def get_workflow_application_service(db: Session = Depends(get_db)) -> WorkflowApplicationService:
    return WorkflowApplicationService(
        app_repository=AppDefinitionRepository(db),
        workflow_repository=WorkflowDefinitionRepository(db),
        app_config_repository=AppConfigRepository(db),
        workflow_config_repository=WorkflowConfigRepository(db))


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


@router.get("/sample", response_model=WorkflowDefinition)
def get_sample_workflow() -> WorkflowDefinition:
    return WorkflowDefinition(
        code="sample_workflow",
        name="Sample Workflow",
        nodes=[
            NodeDefinition(id="start", type="llm"),
            NodeDefinition(id="end", type="answer"),
        ],
        edges=[EdgeDefinition(source="start", target="end")])


@router.post("/sample", response_model=WorkflowDefinition)
def get_sample_workflow_post() -> WorkflowDefinition:
    return get_sample_workflow()


@router.post("/designer/validate", response_model=WorkflowDesignerValidateResponse)
def validate_workflow_designer_dsl(
    payload: WorkflowDesignerValidateRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowDesignerValidateResponse:
    inspection = service.validate_designer_workflow(payload)
    return WorkflowDesignerValidateResponse.from_inspection(inspection)


@router.post("/designer/debug", response_model=WorkflowDebuggerPlanResponse)
def debug_workflow_designer_dsl(
    payload: WorkflowDebuggerPlanRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowDebuggerPlanResponse:
    plan = service.build_designer_debug_plan(payload)
    return WorkflowDebuggerPlanResponse.from_plan(plan)


@router.post("/apps", response_model=AppResponse)
def create_app(
    payload: AppCreateRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> AppResponse:
    entity = service.create_app(payload)
    return AppResponse.from_entity(entity)


@router.get("/apps", response_model=list[AppResponse])
def list_apps(
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[AppResponse]:
    return [AppResponse.from_entity(item) for item in service.list_apps()]


@router.post("/apps/list", response_model=list[AppResponse])
def list_apps_post(
    payload: AppListRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[AppResponse]:
    return [AppResponse.from_entity(item) for item in service.list_apps()]


@router.post("/apps/configs", response_model=AppConfigResponse)
def create_app_config(
    payload: AppConfigCreateRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> AppConfigResponse:
    entity = service.create_app_config(payload)
    return AppConfigResponse.from_entity(entity)


@router.get("/apps/configs", response_model=list[AppConfigResponse])
def list_app_configs(
    app_id: str = Query(...),
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[AppConfigResponse]:
    return [AppConfigResponse.from_entity(item) for item in service.list_app_configs(app_id)]


@router.post("/apps/configs/list", response_model=list[AppConfigResponse])
def list_app_configs_post(
    payload: AppConfigListRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[AppConfigResponse]:
    return [AppConfigResponse.from_entity(item) for item in service.list_app_configs(payload.app_id)]


@router.post("", response_model=WorkflowDefinitionResponse)
def create_workflow(
    payload: WorkflowCreateRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowDefinitionResponse:
    entity = service.create_workflow(payload)
    return WorkflowDefinitionResponse.from_entity(entity)


@router.get("", response_model=list[WorkflowDefinitionResponse])
def list_workflows(
    app_id: str | None = Query(default=None),
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[WorkflowDefinitionResponse]:
    items = service.list_workflows(app_id=app_id)
    return [WorkflowDefinitionResponse.from_entity(item) for item in items]


@router.post("/list", response_model=list[WorkflowDefinitionResponse])
def list_workflows_post(
    payload: WorkflowListRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[WorkflowDefinitionResponse]:
    items = service.list_workflows(app_id=payload.app_id)
    return [WorkflowDefinitionResponse.from_entity(item) for item in items]


@router.post("/configs", response_model=WorkflowConfigResponse)
def create_workflow_config(
    payload: WorkflowConfigCreateRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowConfigResponse:
    try:
        entity = service.create_workflow_config(payload)
    except ValueError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    return WorkflowConfigResponse.from_entity(entity)


@router.get("/configs", response_model=list[WorkflowConfigResponse])
def list_workflow_configs(
    workflow_id: str = Query(...),
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[WorkflowConfigResponse]:
    items = service.list_workflow_configs(workflow_id=workflow_id)
    return [WorkflowConfigResponse.from_entity(item) for item in items]


@router.post("/configs/list", response_model=list[WorkflowConfigResponse])
def list_workflow_configs_post(
    payload: WorkflowConfigListRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> list[WorkflowConfigResponse]:
    items = service.list_workflow_configs(workflow_id=payload.workflow_id)
    return [WorkflowConfigResponse.from_entity(item) for item in items]


@router.get("/configs/{workflow_config_id}", response_model=WorkflowConfigResponse)
def get_workflow_config(
    workflow_config_id: str,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowConfigResponse:
    entity = service.get_workflow_config(workflow_config_id=workflow_config_id)
    if entity is None:
        raise HTTPException(status_code=404, detail=f"workflow_config not found: {workflow_config_id}")
    return WorkflowConfigResponse.from_entity(entity)


@router.post("/configs/detail", response_model=WorkflowConfigResponse)
def get_workflow_config_post(
    payload: WorkflowConfigDetailRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowConfigResponse:
    entity = service.get_workflow_config(workflow_config_id=payload.workflow_config_id)
    if entity is None:
        raise HTTPException(
            status_code=404,
            detail=f"workflow_config not found: {payload.workflow_config_id}")
    return WorkflowConfigResponse.from_entity(entity)


@router.get("/configs/{workflow_config_id}/debug", response_model=WorkflowDebuggerPlanResponse)
def debug_workflow_config(
    workflow_config_id: str,
    max_preview_steps: int = Query(default=50, ge=1, le=500),
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowDebuggerPlanResponse:
    plan = service.build_config_debug_plan(
        workflow_config_id=workflow_config_id,
        max_preview_steps=max_preview_steps)
    if plan is None:
        raise HTTPException(status_code=404, detail=f"workflow_config not found: {workflow_config_id}")
    return WorkflowDebuggerPlanResponse.from_plan(plan)


@router.post("/configs/debug", response_model=WorkflowDebuggerPlanResponse)
def debug_workflow_config_post(
    payload: WorkflowConfigDebuggerPlanRequest,
    service: WorkflowApplicationService = Depends(get_workflow_application_service)) -> WorkflowDebuggerPlanResponse:
    plan = service.build_config_debug_plan(
        workflow_config_id=payload.workflow_config_id,
        max_preview_steps=payload.max_preview_steps)
    if plan is None:
        raise HTTPException(
            status_code=404,
            detail=f"workflow_config not found: {payload.workflow_config_id}")
    return WorkflowDebuggerPlanResponse.from_plan(plan)