Struct CustomRouterConfig

pub struct CustomRouterConfig {
    pub name: Option<String>,
    pub path_prefix: Option<String>,
}

Configuration for custom router attachment

Fields

name: Option<String>

Optional name for the custom router (for logging/debugging)

path_prefix: Option<String>

Optional path prefix for the router

Implementations

impl CustomRouterConfig

pub fn with_name(name: impl Into<String>) -> Self

Create a new custom router configuration with a name

pub fn with_prefix(path_prefix: impl Into<String>) -> Self

Create a new custom router configuration with a path prefix

Examples found in repository

examples/simple_custom_router_test.rs (line 58)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

pub fn with_name_and_prefix( name: impl Into<String>, path_prefix: impl Into<String>, ) -> Self

Create a new custom router configuration with both name and path prefix

Examples found in repository

examples/custom_router_example.rs (line 151)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for logging
    tracing_subscriber::fmt::init();

    // Create GitHub OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "demo_client_id".to_string()),
        client_secret: std::env::var("GITHUB_CLIENT_SECRET").unwrap_or_else(|_| "demo_client_secret".to_string()),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    
    // 1. Health and basic endpoints router
    let health_router = Router::new()
        .route("/health", get(health_check))
        .route("/webhooks", post(webhook_handler));

    // 2. Monitoring router with path prefix
    let monitoring_router = Router::new()
        .route("/metrics", get(metrics));

    // 3. API router with versioned endpoints
    let api_router = Router::new()
        .route("/v1/status", get(api_status))
        .route("/{version}/status", get(api_status));

    // 4. Admin router with HTML interface
    let admin_router = Router::new()
        .route("/", get(admin_dashboard));

    // Configure custom routers with different configurations
    let custom_routers = vec![
        // Health router without prefix (attached to root)
        (health_router, CustomRouterConfig::default()),
        
        // Monitoring router with prefix and name
        (
            monitoring_router,
            CustomRouterConfig::with_name_and_prefix("Monitoring", "/monitoring"),
        ),
        
        // API router with prefix
        (
            api_router,
            CustomRouterConfig::with_name_and_prefix("API", "/api"),
        ),
        
        // Admin router with prefix
        (
            admin_router,
            CustomRouterConfig::with_name_and_prefix("Admin Dashboard", "/admin"),
        ),
    ];

    // Build the microkernel server with OAuth provider and custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_routers(custom_routers);

    // Define the bind address
    let bind_address: SocketAddr = "127.0.0.1:8080".parse()?;

    // Print available endpoints
    println!("🚀 Starting microkernel server with custom routers...");
    println!("📍 Server listening on: http://{}", bind_address);
    println!("\n📋 Available endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom Endpoints:");
    println!("    GET  /health                  - Health check");
    println!("    POST /webhooks                - Webhook handler");
    println!("    GET  /monitoring/metrics      - System metrics");
    println!("    GET  /api/v1/status           - API status");
    println!("    GET  /api/{{version}}/status   - Versioned API status");
    println!("    GET  /admin                   - Admin dashboard");
    println!("\n🔧 Try these commands:");
    println!("  curl http://localhost:8080/health");
    println!("  curl http://localhost:8080/monitoring/metrics");
    println!("  curl http://localhost:8080/api/v1/status");
    println!("  open http://localhost:8080/admin");

    // Start the server
    microkernel.serve(bind_address).await?;

    Ok(())
}

Trait Implementations

impl Clone for CustomRouterConfig

fn clone(&self) -> CustomRouterConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CustomRouterConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CustomRouterConfig

fn default() -> Self

Returns the “default value” for a type.