Struct axum_extra::routing::SpaRouter

pub struct SpaRouter<B = Body, T = (), F = fn(_: Error) -> Ready<StatusCode>> { /* private fields */ }

Router for single page applications.

SpaRouter gives a routing setup commonly used for single page applications.

Example

use axum_extra::routing::SpaRouter;
use axum::{Router, routing::get};

let spa = SpaRouter::new("/assets", "dist");

let app = Router::new()
    // `SpaRouter` implements `Into<Router>` so it works with `merge`
    .merge(spa)
    // we can still add other routes
    .route("/api/foo", get(api_foo));

async fn api_foo() {}

With this setup we get this behavior:

• GET / will serve index.html
• GET /assets/app.js will serve dist/app.js assuming that file exists
• GET /assets/doesnt_exist will respond with 404 Not Found assuming no such file exists
• GET /some/other/path will serve index.html since there isn’t another route for it
• GET /api/foo will serve the api_foo handler function

Implementations

impl<B> SpaRouter<B, (), fn(_: Error) -> Ready<StatusCode>>

pub fn new<P>(serve_assets_at: &str, assets_dir: P) -> Self where
    P: AsRef<Path>, 

Available on crate feature spa only.

Create a new SpaRouter.

Assets will be served at GET /{serve_assets_at} from the directory at assets_dir.

The index file defaults to assets_dir.join("index.html").

impl<B, T, F> SpaRouter<B, T, F>

pub fn index_file<P>(self, path: P) -> Self where
    P: AsRef<Path>, 

Available on crate feature spa only.

Set the path to the index file.

path must be relative to assets_dir passed to SpaRouter::new.

Example

use axum_extra::routing::SpaRouter;
use axum::Router;

let spa = SpaRouter::new("/assets", "dist")
    .index_file("another_file.html");

let app = Router::new().merge(spa);

pub fn handle_error<T2, F2>(self, f: F2) -> SpaRouter<B, T2, F2>

Available on crate feature spa only.

Change the function used to handle unknown IO errors.

SpaRouter automatically maps missing files and permission denied to 404 Not Found. The callback given here will be used for other IO errors.

See axum::error_handling::HandleErrorLayer for more details.

Example

use std::io;
use axum_extra::routing::SpaRouter;
use axum::{Router, http::{Method, Uri}};

let spa = SpaRouter::new("/assets", "dist").handle_error(handle_error);

async fn handle_error(method: Method, uri: Uri, err: io::Error) -> String {
    format!("{} {} failed with {}", method, uri, err)
}

let app = Router::new().merge(spa);

Trait Implementations

impl<B, T, F> Clone for SpaRouter<B, T, F> where
    F: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, T, F> Debug for SpaRouter<B, T, F>

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

Formats the value using the given formatter.

impl<B, F, T> From<SpaRouter<B, T, F>> for Router<B> where
    F: Clone + Send + 'static,
    HandleError<Route<B, Error>, F, T>: Service<Request<B>, Response = Response, Error = Infallible>,
    <HandleError<Route<B, Error>, F, T> as Service<Request<B>>>::Future: Send,
    B: HttpBody + Send + 'static,
    T: 'static, 

fn from(spa: SpaRouter<B, T, F>) -> Self

Converts to this type from the input type.