storkit/server/src/http/mod.rs

pub mod anthropic;
pub mod assets;
pub mod chat;
pub mod context;
pub mod health;
pub mod io;
pub mod model;

pub mod project;
pub mod ws;

use anthropic::AnthropicApi;
use chat::ChatApi;
use context::AppContext;
use io::IoApi;
use model::ModelApi;
use poem::EndpointExt;
use poem::{Route, get};
use poem_openapi::OpenApiService;
use project::ProjectApi;
use std::sync::Arc;

pub fn build_routes(ctx: AppContext) -> impl poem::Endpoint {
    let ctx_arc = std::sync::Arc::new(ctx);

    let (api_service, docs_service) = build_openapi_service(ctx_arc.clone());

    Route::new()
        .nest("/api", api_service)
        .nest("/docs", docs_service.swagger_ui())
        .at("/ws", get(ws::ws_handler))
        .at("/health", get(health::health))
        .at("/assets/*path", get(assets::embedded_asset))
        .at("/", get(assets::embedded_index))
        .at("/*path", get(assets::embedded_file))
        .data(ctx_arc)
}

type ApiTuple = (ProjectApi, ModelApi, AnthropicApi, IoApi, ChatApi);

type ApiService = OpenApiService<ApiTuple, ()>;

/// All HTTP methods are documented by OpenAPI at /docs
pub fn build_openapi_service(ctx: Arc<AppContext>) -> (ApiService, ApiService) {
    let api = (
        ProjectApi { ctx: ctx.clone() },
        ModelApi { ctx: ctx.clone() },
        AnthropicApi::new(ctx.clone()),
        IoApi { ctx: ctx.clone() },
        ChatApi { ctx: ctx.clone() },
    );

    let api_service =
        OpenApiService::new(api, "Story Kit API", "1.0").server("http://127.0.0.1:3001/api");

    let docs_api = (
        ProjectApi { ctx: ctx.clone() },
        ModelApi { ctx: ctx.clone() },
        AnthropicApi::new(ctx.clone()),
        IoApi { ctx: ctx.clone() },
        ChatApi { ctx },
    );

    let docs_service =
        OpenApiService::new(docs_api, "Story Kit API", "1.0").server("http://127.0.0.1:3001/api");

    (api_service, docs_service)
}