Struct OpenApiRouter 

pub struct OpenApiRouter<H> { /* private fields */ }

Available on crate feature openapi-router and non-WebAssembly only.

Router wrapper that adds OpenAPI documentation endpoints

This wrapper intercepts requests to OpenAPI documentation paths and serves them from memory, delegating all other requests to the wrapped handler.

The OpenAPI schema is generated once at wrap time from the global schema registry, ensuring minimal runtime overhead.

Access control is supported via the enabled flag and an optional authentication guard callback. When enabled is false, all documentation endpoints return HTTP 404. When an auth guard is set and returns false, endpoints return HTTP 403.

Implementations

impl<H> OpenApiRouter<H>

pub fn wrap(handler: H) -> Result<OpenApiRouter<H>, SchemaError>

Wrap an existing handler with OpenAPI endpoints

This generates the OpenAPI schema from the global registry and pre-renders the Swagger and Redoc UIs.

Example

use reinhardt_openapi::OpenApiRouter;
use reinhardt_urls::routers::BasicRouter;

let router = BasicRouter::new();
let wrapped = OpenApiRouter::wrap(router)?;

pub fn enabled(self, enabled: bool) -> OpenApiRouter<H>

Set whether documentation endpoints are enabled

When set to false, all documentation endpoints (/api/openapi.json, /api/docs, /api/redoc) will return HTTP 404 Not Found.

Default is true.

Example

use reinhardt_openapi::OpenApiRouter;
use reinhardt_urls::routers::BasicRouter;

let router = BasicRouter::new();
let wrapped = OpenApiRouter::wrap(router)?.enabled(false);

pub fn auth_guard( self, guard: impl Fn(&Request) -> bool + Send + Sync + 'static, ) -> OpenApiRouter<H>

Set an authentication guard for documentation endpoints

The guard function receives a reference to the incoming request and should return true to allow access or false to deny with HTTP 403 Forbidden.

The guard is only checked when enabled is true. When enabled is false, endpoints return 404 regardless of the guard.

Example

use reinhardt_openapi::OpenApiRouter;
use reinhardt_urls::routers::BasicRouter;

let router = BasicRouter::new();
let wrapped = OpenApiRouter::wrap(router)?.auth_guard(|request| {
    // Check for API key in header
    request.headers().get("X-Api-Key")
        .map(|v| v == "secret")
        .unwrap_or(false)
});

pub fn inner(&self) -> &H

Get a reference to the wrapped handler

Trait Implementations

impl<H> Handler for OpenApiRouter<H>

where H: Handler,

fn handle<'life0, 'async_trait>( &'life0 self, request: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, OpenApiRouter<H>: 'async_trait,

Handle requests, intercepting OpenAPI documentation paths

Requests to /api/openapi.json, /api/docs, or /api/redoc are served from memory if access control checks pass. All other requests are delegated to the wrapped handler.

Access control is enforced via the enabled flag and optional auth guard. Disabled endpoints return 404, unauthorized requests return 403.

impl<H> Router for OpenApiRouter<H>

where H: Handler + Router,

Router trait implementation for OpenApiRouter

This implementation allows OpenApiRouter to be used where Router trait is required. However, routes cannot be modified after wrapping - use add_route() and include() on the base router before wrapping.

fn add_route(&mut self, _route: Route)

Add a route to the router

Panics

This method always panics. Routes must be added to the base router before wrapping with OpenApiRouter::wrap().

fn mount( &mut self, _prefix: &str, _routes: Vec<Route>, _namespace: Option<String>, )

Include routes with a prefix

Panics

This method always panics. Routes must be mounted in the base router before wrapping with OpenApiRouter::wrap().

async fn route(&self, request: Request) -> Result<Response, Error>

Route a request through the OpenAPI wrapper

OpenAPI documentation endpoints (/api/openapi.json, /api/docs, /api/redoc) are handled directly if access control checks pass. All other requests are delegated to the wrapped router’s route() method.

Access control is enforced via the enabled flag and optional auth guard. Disabled endpoints return 404, unauthorized requests return 403.