Trait poem::EndpointExt[−][src]

pub trait EndpointExt: IntoEndpoint {
    fn boxed<'a>(self) -> BoxEndpoint<'a, <Self::Endpoint as Endpoint>::Output>
    where
        Self: Sized + 'a,
    { ... }

    fn with<T>(self, middleware: T) -> T::Output
    where
        T: Middleware<Self::Endpoint>,
        Self: Sized,
    { ... }

    fn data<T>(self, data: T) -> AddDataEndpoint<Self::Endpoint, T>
    where
        T: Clone + Send + Sync + 'static,
        Self: Sized,
    { ... }

    fn before<F, Fut>(self, f: F) -> Before<Self, F>
    where
        F: Fn(Request) -> Fut + Send + Sync,
        Fut: Future<Output = Request> + Send,
        Self: Sized,
    { ... }

    fn after<F, Fut, R>(self, f: F) -> After<Self::Endpoint, F>
    where
        F: Fn(<Self::Endpoint as Endpoint>::Output) -> Fut + Send + Sync,
        Fut: Future<Output = R> + Send,
        R: IntoResponse,
        Self: Sized,
    { ... }

    fn around<F, R>(self, f: F) -> Around<Self::Endpoint, F>
    where
        F: for<'a> Fn(&'a Self::Endpoint, Request) -> BoxFuture<'a, R> + Send + Sync,
        R: IntoResponse,
        Self: Sized,
    { ... }

    fn map_to_response(self) -> MapToResponse<Self::Endpoint>
    where
        Self: Sized,
    { ... }

    fn map_to_result(self) -> MapToResult<Self::Endpoint>
    where
        Self: Sized,
    { ... }

    fn and_then<F, Fut, Err, R, R2>(self, f: F) -> AndThen<Self::Endpoint, F>
    where
        F: Fn(R) -> Fut + Send + Sync,
        Fut: Future<Output = Result<R2, Err>> + Send,
        Err: IntoResponse,
        R: IntoResponse,
        R2: IntoResponse,
        Self: Sized,
        Self::Endpoint: Endpoint<Output = Result<R, Err>> + Sized,
    { ... }

    fn map_ok<F, Fut, Err, R, R2>(self, f: F) -> MapOk<Self::Endpoint, F>
    where
        F: Fn(R) -> Fut + Send + Sync,
        Fut: Future<Output = R2> + Send,
        R: IntoResponse,
        R2: IntoResponse,
        Self: Sized,
        Self::Endpoint: Endpoint<Output = Result<R, Err>> + Sized,
    { ... }

    fn map_err<F, Fut, InErr, OutErr, R>(
        self, 
        f: F
    ) -> MapErr<Self::Endpoint, F>
    where
        F: Fn(InErr) -> Fut + Send + Sync,
        Fut: Future<Output = OutErr> + Send,
        InErr: IntoResponse,
        OutErr: IntoResponse,
        R: IntoResponse,
        Self: Sized,
        Self::Endpoint: Endpoint<Output = Result<R, InErr>> + Sized,
    { ... }
}
Expand description

Extension trait for Endpoint.

Provided methods

Wrap the endpoint in a Box.

Use middleware to transform this endpoint.

Example
use poem::{
    get, handler, http::StatusCode, middleware::AddData, web::Data, Endpoint, EndpointExt,
    Request, Route,
};

#[handler]
async fn index(Data(data): Data<&i32>) -> String {
    format!("{}", data)
}

let app = Route::new().at("/", get(index)).with(AddData::new(100i32));
let resp = app.call(Request::default()).await;
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "100");

A helper function, similar to with(AddData(T)).

Example
use poem::{handler, http::StatusCode, web::Data, Endpoint, EndpointExt, Request};

#[handler]
async fn index(data: Data<&i32>) -> String {
    format!("{}", data.0)
}

let mut resp = index.data(100i32).call(Request::default()).await;
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.take_body().into_string().await.unwrap(), "100");

Maps the request of this endpoint.

Example
use poem::{handler, http::StatusCode, Endpoint, EndpointExt, Error, Request, Result};

#[handler]
async fn index(data: String) -> String {
    data
}

let mut resp = index
    .before(|mut req| async move {
        req.set_body("abc");
        req
    })
    .call(Request::default())
    .await;
assert_eq!(resp.take_body().into_string().await.unwrap(), "abc");

Maps the output of this endpoint.

Example
use poem::{handler, http::StatusCode, Endpoint, EndpointExt, Error, Request, Result};

#[handler]
async fn index() -> &'static str {
    "abc"
}

let mut resp = index
    .after(|mut resp| async move { resp.take_body().into_string().await.unwrap() + "def" })
    .call(Request::default())
    .await;
assert_eq!(resp, "abcdef");

Maps the request and response of this endpoint.

Example
use poem::{
    handler,
    http::{HeaderMap, HeaderValue, StatusCode},
    Endpoint, EndpointExt, Error, Request, Result,
};

#[handler]
async fn index(headers: &HeaderMap) -> String {
    headers
        .get("x-value")
        .and_then(|value| value.to_str().ok())
        .unwrap()
        .to_string()
        + ","
}

let mut resp = index
    .around(|ep, mut req| {
        Box::pin(async move {
            req.headers_mut()
                .insert("x-value", HeaderValue::from_static("hello"));
            let mut resp = ep.call(req).await;
            resp.take_body().into_string().await.unwrap() + "world"
        })
    })
    .call(Request::default())
    .await;
assert_eq!(resp, "hello,world");

Convert the output of this endpoint into a response. Response.

Example
use poem::{
    endpoint::make, http::StatusCode, Endpoint, EndpointExt, Error, Request, Response, Result,
};

let ep =
    make(|_| async { Err::<(), Error>(Error::new(StatusCode::BAD_REQUEST)) }).map_to_response();

let resp: Response = ep.call(Request::default()).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

Convert the output of this endpoint into a result Result<Response>. Response.

Example
use poem::{
    endpoint::make, http::StatusCode, Endpoint, EndpointExt, Error, Request, Response, Result,
};

let ep = make(|_| async { Response::builder().status(StatusCode::BAD_REQUEST).finish() })
    .map_to_result();

let resp: Result<Response> = ep.call(Request::default()).await;
assert_eq!(resp.unwrap_err().status(), StatusCode::BAD_REQUEST);

Calls f if the result is Ok, otherwise returns the Err value of self.

Example
use poem::{
    endpoint::make, http::StatusCode, Endpoint, EndpointExt, Error, Request, Response, Result,
};

let ep1 = make(|_| async { Ok::<_, Error>("hello") })
    .and_then(|value| async move { Ok(format!("{}, world!", value)) });
let ep2 = make(|_| async { Err::<String, _>(Error::new(StatusCode::BAD_REQUEST)) })
    .and_then(|value| async move { Ok(format!("{}, world!", value)) });

let resp: String = ep1.call(Request::default()).await.unwrap();
assert_eq!(resp, "hello, world!");

let err: Error = ep2.call(Request::default()).await.unwrap_err();
assert_eq!(err.status(), StatusCode::BAD_REQUEST);

Maps the response of this endpoint.

Example
use poem::{
    endpoint::make, http::StatusCode, Endpoint, EndpointExt, Error, Request, Response, Result,
};

let ep =
    make(|_| async { Ok("hello") }).map_ok(|value| async move { format!("{}, world!", value) });

let mut resp: String = ep.call(Request::default()).await.unwrap();
assert_eq!(resp, "hello, world!");

Maps the error of this endpoint.

Example
use poem::{
    endpoint::make, http::StatusCode, Endpoint, EndpointExt, Error, IntoResponse, Request,
    Response, Result,
};

struct CustomError;

impl IntoResponse for CustomError {
    fn into_response(self) -> Response {
        Response::builder()
            .status(StatusCode::UNAUTHORIZED)
            .finish()
    }
}

let ep = make(|_| async { Err::<(), _>(CustomError) })
    .map_err(|_| async move { Error::new(StatusCode::INTERNAL_SERVER_ERROR) });

let err = ep.call(Request::default()).await.unwrap_err();
assert_eq!(err.status(), StatusCode::INTERNAL_SERVER_ERROR);

Implementors