remote-mcp-kernel 0.1.0-alpha.2

//! Factory functions for microkernel server creation
//!
//! This module provides convenient factory functions for creating
//! microkernel servers with different OAuth providers and configurations.

use crate::handlers::{McpServer, SseHandler, SseHandlerConfig, StreamableHttpHandler};
use oauth_provider_rs::storage::create_dynamodb_storage;
use oauth_provider_rs::{
    CognitoOAuthProvider, DefaultClientManager, GitHubOAuthProvider, OAuthProvider,
    OAuthProviderTrait, OAuthStorage, storage::DynamoDBStorage,
};

use super::{
    core::MicrokernelServer,
    types::{CognitoMicrokernelServer, CognitoMicrokernelServerDynamoDB, GitHubMicrokernelServer},
};

/// Create a fully configured microkernel server with all handlers
pub fn create_full_microkernel<
    P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
    S: OAuthStorage + Clone + 'static,
>(
    oauth_provider: OAuthProvider<P, S>,
) -> MicrokernelServer<P, S> {
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_config = SseHandlerConfig::default();

    MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, sse_config)
}

/// Create a fully configured microkernel server with GitHub OAuth provider
pub fn create_full_github_microkernel(
    oauth_provider: GitHubOAuthProvider,
) -> GitHubMicrokernelServer {
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_config = SseHandlerConfig::default();

    MicrokernelServer::new()
        .with_oauth_provider(wrapped_oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, sse_config)
}

/// Create a fully configured microkernel server with Cognito OAuth provider
pub fn create_full_cognito_microkernel(
    oauth_provider: CognitoOAuthProvider,
) -> CognitoMicrokernelServer {
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_config = SseHandlerConfig::default();

    MicrokernelServer::new()
        .with_oauth_provider(wrapped_oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, sse_config)
}

/// Create a minimal microkernel server with GitHub OAuth provider
pub fn create_github_oauth_only_microkernel(
    oauth_provider: GitHubOAuthProvider,
) -> GitHubMicrokernelServer {
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider)
}

/// Create a minimal microkernel server with Cognito OAuth provider
pub fn create_cognito_oauth_only_microkernel(
    oauth_provider: CognitoOAuthProvider,
) -> CognitoMicrokernelServer {
    let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
    MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider)
}

/// Create a fully configured microkernel server with Cognito OAuth provider and DynamoDB storage
pub async fn create_full_cognito_microkernel_dynamodb(
    cognito_config: oauth_provider_rs::CognitoOAuthConfig,
    cognito_domain: String,
    region: String,
    user_pool_id: String,
    table_name: String,
    create_table: bool,
) -> Result<CognitoMicrokernelServerDynamoDB<DynamoDBStorage>, Box<dyn std::error::Error>> {
    // Create DynamoDB storage
    let (storage, client_manager) =
        create_dynamodb_storage(table_name, create_table, Some("expires_at".to_string())).await?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        cognito_domain,
        region,
        user_pool_id,
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create all MCP handlers
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_config = SseHandlerConfig::default();

    // Build and return the microkernel server
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, sse_config);

    Ok(microkernel)
}

/// Create a minimal microkernel server with only OAuth
pub fn create_oauth_only_microkernel<
    P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
    S: OAuthStorage + Clone + 'static,
>(
    oauth_provider: OAuthProvider<P, S>,
) -> MicrokernelServer<P, S> {
    MicrokernelServer::new().with_oauth_provider(oauth_provider)
}

/// Create a microkernel server without authentication (for testing)
pub fn create_unauthenticated_microkernel<
    P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
    S: OAuthStorage + Clone + 'static,
>(
    oauth_provider: OAuthProvider<P, S>,
) -> MicrokernelServer<P, S> {
    let mcp_server = McpServer::new();
    let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
    let sse_handler = SseHandler::new(mcp_server.clone());
    let sse_config = SseHandlerConfig {
        require_auth: false,
        ..Default::default()
    };

    MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_streamable_handler(streamable_handler)
        .with_sse_handler(sse_handler, sse_config)
}