Struct Router 

pub struct Router { /* private fields */ }

Router manages handler registration and protocol adapters

The router allows you to register handlers once and expose them via multiple protocols based on configuration.

Implementations

impl Router

pub fn docs_config(&self, path: &str, title: &str, version: &str) -> DocsConfig

Get documentation configuration helper

Returns a DocsConfig that can be used to serve documentation.

pub fn openapi_json(&self, title: &str, version: &str) -> String

Generate OpenAPI JSON for serving at /docs/openapi.json

This is a convenience method that generates the OpenAPI spec in JSON format ready to be served via HTTP.

pub fn openapi_json_with_description( &self, title: &str, version: &str, description: &str, ) -> String

Generate OpenAPI JSON with description

pub fn docs_html(&self, config: &DocsConfig) -> String

Generate a basic HTML page for documentation

Returns a simple HTML page that can serve as a landing page for API documentation. In production, you’d want to use a proper documentation UI like Scalar or Swagger UI.

impl Router

pub fn to_openapi(&self, title: &str, version: &str) -> Value

Generate OpenAPI 3.1 specification

This is a convenience method that creates an OpenAPI specification for all REST routes registered with this router.

pub fn to_openapi_with_description( &self, title: &str, version: &str, description: &str, ) -> Value

Generate OpenAPI 3.1 specification with description

impl Router

pub fn new() -> Self

Create a new router

pub fn with_config(config: RouterConfig) -> Self

Available on crate feature router only.

Create a new router with configuration

pub fn register<F, Fut>(&mut self, name: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a handler with a name

pub fn handlers_count(&self) -> usize

Get the number of registered handlers

pub fn add_adapter(&mut self, adapter: Box<dyn ProtocolAdapter>)

Add a protocol adapter

pub fn has_adapter(&self, name: &str) -> bool

Check if an adapter is registered

pub fn get_adapter(&self, name: &str) -> Option<&dyn ProtocolAdapter>

Get an adapter by name

pub async fn route_request( &self, protocol: &str, request: &str, ) -> Result<String, String>

Route a request through the appropriate protocol adapter

pub async fn execute(&self, name: &str) -> Result<String, String>

Execute a handler by name

pub fn list_handlers(&self) -> Vec<String>

List all registered handler names

Returns a vector of all handler names that have been registered with this router. Used by MCP server for tool discovery.

pub async fn call_handler( &self, name: &str, _request: &str, ) -> Result<String, String>

Call a handler by name with request data

This is an alias for execute() that provides a more explicit API for directly calling handlers. Used by MCP server.

pub fn can_handle_rest(&self, _name: &str) -> bool

Check if handler can be called via REST

pub fn can_handle_graphql(&self, _name: &str) -> bool

Check if handler can be called via GraphQL

pub fn can_handle_grpc(&self, _name: &str) -> bool

Check if handler can be called via gRPC

pub fn enabled_protocols(&self) -> Vec<String>

Get list of enabled protocols

pub fn add_route(&mut self, metadata: RouteMetadata)

Add a route with metadata

This stores route metadata that can be used to generate documentation (OpenAPI, GraphQL schemas, gRPC reflection).

pub fn routes(&self) -> &[RouteMetadata]

Get all registered routes

Returns an immutable reference to all route metadata. This is used for documentation generation.

pub fn get<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a GET route

This is a convenience method that registers both a handler and route metadata for a GET request. The handler name is automatically generated as “GET:{path}”.

pub fn post<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a POST route

This is a convenience method that registers both a handler and route metadata for a POST request. The handler name is automatically generated as “POST:{path}”.

pub fn put<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a PUT route

This is a convenience method that registers both a handler and route metadata for a PUT request. The handler name is automatically generated as “PUT:{path}”.

pub fn delete<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a DELETE route

This is a convenience method that registers both a handler and route metadata for a DELETE request. The handler name is automatically generated as “DELETE:{path}”.

pub fn patch<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a PATCH route

This is a convenience method that registers both a handler and route metadata for a PATCH request. The handler name is automatically generated as “PATCH:{path}”.

pub fn head<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register a HEAD route

This is a convenience method that registers both a handler and route metadata for a HEAD request. The handler name is automatically generated as “HEAD:{path}”.

pub fn options<F, Fut>(&mut self, path: &str, handler: F)

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = String> + Send + 'static,

Register an OPTIONS route

This is a convenience method that registers both a handler and route metadata for an OPTIONS request. The handler name is automatically generated as “OPTIONS:{path}”.

pub async fn call_rest( &self, method: &str, path: &str, ) -> Result<String, String>

Call handler via REST

pub async fn call_graphql(&self, query: &str) -> Result<String, String>

Call handler via GraphQL

pub async fn call_grpc( &self, method: &str, request: &str, ) -> Result<String, String>

Call handler via gRPC

pub fn scalar(&self, title: &str, version: &str) -> String

Generate Scalar documentation HTML with default configuration

This is a convenience method that generates a complete HTML page with Scalar UI for interactive API documentation.

Arguments

• title - API title
• version - API version

Example

use allframe_core::router::Router;

let mut router = Router::new();
router.get("/users", || async { "Users".to_string() });

let html = router.scalar("My API", "1.0.0");
// Serve this HTML at /docs endpoint

pub fn scalar_docs( &self, config: ScalarConfig, title: &str, version: &str, ) -> String

Generate Scalar documentation HTML with custom configuration

This method allows full customization of the Scalar UI appearance and behavior.

Arguments

• config - Scalar configuration
• title - API title
• version - API version

Example

use allframe_core::router::{Router, ScalarConfig, ScalarTheme};

let mut router = Router::new();
router.get("/users", || async { "Users".to_string() });

let config = ScalarConfig::new()
    .theme(ScalarTheme::Light)
    .show_sidebar(false);

let html = router.scalar_docs(config, "My API", "1.0.0");

Trait Implementations

impl ContractTestable for Router

fn generate_contract_tests(&self) -> ContractTestResults

Generate contract tests for all routes

fn test_route_contract(&self, path: &str, method: &str) -> ContractTestResult

Test a specific route path and method

impl Default for Router

fn default() -> Self

Returns the “default value” for a type.