Struct Router

Source

#[non_exhaustive]
pub struct Router { /* private fields */ }

Expand description

A wrapper around Axum’s Router to provide clean integration with Rullst features

Implementations§

Source §

impl Router

Source

pub fn new() -> Self

Creates a new empty Router with no routes configured.

Source

pub fn route<T>(self, path: &str, method_router: T) -> Self
where T: Into<MethodRouter>,

Registers an HTTP route at the given path with the given method router. method_router is typically the result of get(handler), post(handler), etc.

Source

pub fn ws<H, T>(self, path: &str, handler: H) -> Self
where T: 'static, H: Handler<T, ()>,

Registers a WebSocket upgrade route at the given path. Internally maps to GET path since WebSocket upgrades happen over HTTP GET.

Source

pub fn into_axum(self) -> AxumRouter

Unwraps the inner axum::Router. Use this to hand the router off to axum::serve or to interoperate with Tower middleware that requires a raw Axum router.

Source

pub fn as_axum(&self) -> &AxumRouter

Returns a reference to the inner axum::Router.

Source

pub fn as_axum_mut(&mut self) -> &mut AxumRouter

Returns a mutable reference to the inner axum::Router.

Source

pub fn fallback<H, T>(self, handler: H) -> Self
where H: Handler<T, ()>, T: 'static,

Adds a fallback handler for requests that do not match any route.

Source

pub fn fallback_service<S>(self, service: S) -> Self
where S: Service<Request, Response = Response, Error = Infallible> + Clone + Send + Sync + 'static, S::Future: Send + 'static,

Adds a fallback Tower service for requests that do not match any route.

Source

pub fn nest(self, path: &str, router: Router) -> Self

Nests another Rullst Router under a path prefix. All routes defined in router will be reachable under path/....

Source

pub fn nest_axum(self, path: &str, router: AxumRouter) -> Self

Nests a raw axum::Router under a path prefix. Useful for integrating third-party Axum routers (e.g. from utoipa, aide) without wrapping.

Source

pub fn merge_axum(self, router: AxumRouter) -> Self

Merges a raw axum::Router into this router at the root.

Equivalent to Router::merge on the inner axum::Router. This is the recommended way to compose a fully-built Axum router (for example, one produced by utoipa_axum::OpenApiRouter::split_for_parts) into a Rullst Router, since axum 0.8+ no longer allows nesting at the root path.

Source

pub fn layer<L>(self, layer: L) -> Self
where L: Layer<Route> + Clone + Send + Sync + 'static, L::Service: Service<Request, Response = Response, Error = Infallible> + Clone + Send + Sync + 'static, <L::Service as Service<Request>>::Future: Send + 'static,

Applies a Tower middleware layer to all routes in this router. The layer is cloned once per request and must be Send + Sync + 'static.

Methods from Deref<Target = AxumRouter>§

Source

pub fn has_routes(&self) -> bool

True if the router currently has at least one route added.

Source

pub fn as_service(&mut self) -> RouterAsService<'_, B, S>

Convert the router into a borrowed Service with a fixed request body type, to aid type inference.

In some cases when calling methods from tower::ServiceExt on a Router you might get type inference errors along the lines of

let response = router.ready().await?.call(request).await?;
                      ^^^^^ cannot infer type for type parameter `B`

This happens because Router implements Service with impl Service<Request> for Router<()>.

For example:

use axum::{
    Router,
    routing::get,
    http::Request,
    body::Body,
};
use tower::{Service, ServiceExt};

let mut router = Router::new().route("/", get(|| async {}));
let request = Request::new(Body::empty());
let response = router.ready().await?.call(request).await?;

Calling Router::as_service fixes that:

use axum::{
    Router,
    routing::get,
    http::Request,
    body::Body,
};
use tower::{Service, ServiceExt};

let mut router = Router::new().route("/", get(|| async {}));
let request = Request::new(Body::empty());
let response = router.as_service().ready().await?.call(request).await?;