Struct Path 

pub struct Path<T>(pub T);

Extractor that will get captures from the URL and parse them using serde.

Any percent encoded parameters will be automatically decoded. The decoded parameters must be valid UTF-8, otherwise Path will fail and return a 400 Bad Request response.

Example

These examples assume the serde feature of the uuid crate is enabled.

One Path can extract multiple captures. It is not necessary (and does not work) to give a handler more than one Path argument.

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use uuid::Uuid;

async fn users_teams_show(
    Path((user_id, team_id)): Path<(Uuid, Uuid)>,
) {
    // ...
}

let app = Router::new().route("/users/:user_id/team/:team_id", get(users_teams_show));

If the path contains only one parameter, then you can omit the tuple.

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use uuid::Uuid;

async fn user_info(Path(user_id): Path<Uuid>) {
    // ...
}

let app = Router::new().route("/users/:user_id", get(user_info));

Path segments also can be deserialized into any type that implements serde::Deserialize. This includes tuples and structs:

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use serde::Deserialize;
use uuid::Uuid;

// Path segment labels will be matched with struct field names
#[derive(Deserialize)]
struct Params {
    user_id: Uuid,
    team_id: Uuid,
}

async fn users_teams_show(
    Path(Params { user_id, team_id }): Path<Params>,
) {
    // ...
}

// When using tuples the path segments will be matched by their position in the route
async fn users_teams_create(
    Path((user_id, team_id)): Path<(String, String)>,
) {
    // ...
}

let app = Router::new().route(
    "/users/:user_id/team/:team_id",
    get(users_teams_show).post(users_teams_create),
);

If you wish to capture all path parameters you can use HashMap or Vec:

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use std::collections::HashMap;

async fn params_map(
    Path(params): Path<HashMap<String, String>>,
) {
    // ...
}

async fn params_vec(
    Path(params): Path<Vec<(String, String)>>,
) {
    // ...
}

let app = Router::new()
    .route("/users/:user_id/team/:team_id", get(params_map).post(params_vec));

Providing detailed rejection output

If the URI cannot be deserialized into the target type the request will be rejected and an error response will be returned. See customize-path-rejection for an example of how to customize that error.

Tuple Fields

0: T

Trait Implementations

impl<T> Debug for Path<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Path<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Path<T> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for Path<T>

fn deref_mut(&mut self) -> &mut <Path<T> as Deref>::Target

Mutably dereferences the value.

impl<T, S> FromRequestParts<S> for Path<T>

where T: DeserializeOwned + Send, S: Send + Sync,

type Rejection = PathRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>( parts: &'life0 mut Parts, _state: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Path<T>, <Path<T> as FromRequestParts<S>>::Rejection>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Path<T>: 'async_trait,

Perform the extraction.

impl<T1> ParameterProvider for Path<(T1,)>

where T1: Schematic,

fn generate(url: String) -> Either<Vec<Parameter>, RequestBody>

impl<T1, T2> ParameterProvider for Path<(T1, T2)>

where T1: Schematic, T2: Schematic,

fn generate(url: String) -> Either<Vec<Parameter>, RequestBody>

impl<T> ParameterProvider for Path<T>

where T: Schematic,

fn generate(_url: String) -> Either<Vec<Parameter>, RequestBody>