Struct poem::web::Path

pub struct Path<T>(pub T);

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

Errors

• ParsePathError

Example

use poem::{
    get, handler,
    http::{StatusCode, Uri},
    web::Path,
    Endpoint, Request, Route,
};

#[handler]
async fn users_teams_show(Path((user_id, team_id)): Path<(String, String)>) -> String {
    format!("{}:{}", user_id, team_id)
}

let app = Route::new().at("/users/:user_id/team/:team_id", get(users_teams_show));
let resp = app
    .call(
        Request::builder()
            .uri(Uri::from_static("/users/100/team/300"))
            .finish(),
    )
    .await
    .unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "100:300");

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

use poem::{
    get, handler,
    http::{StatusCode, Uri},
    web::Path,
    Endpoint, Request, Route,
};

#[handler]
async fn user_info(Path(user_id): Path<String>) -> String {
    user_id
}

let app = Route::new().at("/users/:user_id", get(user_info));
let resp = app
    .call(
        Request::builder()
            .uri(Uri::from_static("/users/100"))
            .finish(),
    )
    .await
    .unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "100");

Path segments also can be deserialized into any type that implements serde::Deserialize. Path segment labels will be matched with struct field names.

use poem::{
    get, handler,
    http::{StatusCode, Uri},
    web::Path,
    Endpoint, Request, Route,
};
use serde::Deserialize;

#[derive(Deserialize)]
struct Params {
    user_id: String,
    team_id: String,
}

#[handler]
async fn users_teams_show(Path(Params { user_id, team_id }): Path<Params>) -> String {
    format!("{}:{}", user_id, team_id)
}

let app = Route::new().at("/users/:user_id/team/:team_id", get(users_teams_show));
let resp = app
    .call(
        Request::builder()
            .uri(Uri::from_static("/users/foo/team/100"))
            .finish(),
    )
    .await
    .unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "foo:100");

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for Path<T>

fn clone(&self) -> Path<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Path<T>

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

Formats the value using the given formatter.

impl<T> Deref for Path<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Path<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T: DeserializeOwned> FromRequest<'a> for Path<T>

fn from_request<'life0, 'async_trait>(
    req: &'a Request,
    _body: &'life0 mut RequestBody
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Extract from request head and body.

fn from_request_without_body<'async_trait>(
    req: &'a Request
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    'a: 'async_trait,
    Self: Send + 'async_trait, 

Extract from request head.

impl<T: PartialEq> PartialEq<Path<T>> for Path<T>

fn eq(&self, other: &Path<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Path<T>) -> bool

This method tests for !=.

impl<T: Eq> Eq for Path<T>

impl<T> StructuralEq for Path<T>

impl<T> StructuralPartialEq for Path<T>