llm-registry-api 0.1.0

//! GraphQL API implementation
//!
//! This module provides a complete GraphQL API for the LLM Registry using async-graphql.
//! It supports queries, mutations, authentication, and includes a GraphQL Playground.

pub mod mutation;
pub mod query;
pub mod types;

use async_graphql::{http::GraphiQLSource, EmptySubscription, Schema};
use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
use axum::{extract::State, response::{Html, IntoResponse}, Extension};
use llm_registry_service::ServiceRegistry;
use std::sync::Arc;

use crate::auth::AuthUser;

pub use mutation::Mutation;
pub use query::Query;

/// GraphQL schema type
pub type AppSchema = Schema<Query, Mutation, EmptySubscription>;

/// Build the GraphQL schema
pub fn build_schema(services: Arc<ServiceRegistry>) -> AppSchema {
    Schema::build(Query, Mutation, EmptySubscription)
        .data(services)
        .finish()
}

/// GraphQL handler with optional authentication
pub async fn graphql_handler(
    State(schema): State<AppSchema>,
    auth_user: Option<Extension<AuthUser>>,
    req: GraphQLRequest,
) -> GraphQLResponse {
    let mut request = req.into_inner();

    // Add authenticated user to context if present
    if let Some(Extension(user)) = auth_user {
        request = request.data(user);
    }

    schema.execute(request).await.into()
}

/// GraphQL Playground handler
pub async fn graphql_playground() -> impl IntoResponse {
    Html(
        GraphiQLSource::build()
            .endpoint("/graphql")
            .title("LLM Registry GraphQL Playground")
            .finish(),
    )
}

// TODO: Fix unit tests
#[cfg(all(test, feature = "incomplete_tests"))]
mod tests {
    use super::*;

    #[test]
    fn test_schema_creation() {
        use llm_registry_db::DatabaseConfig;
        use llm_registry_service::ServiceRegistry;

        // This is a smoke test to ensure the schema can be created
        let db_config = DatabaseConfig::default();
        let services = ServiceRegistry::new(db_config);
        let schema = build_schema(Arc::new(services));

        // Schema should have the Query and Mutation types
        assert!(schema.sdl().contains("type Query"));
        assert!(schema.sdl().contains("type Mutation"));
    }
}