Trait axum::RequestExt

source · 
pub trait RequestExt<B>: Sealed<B> + Sized {
    fn extract<E, M>(
        self
    ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequest<(), B, M>>::Rejection>> + Send + 'static, Global>>
    where
        E: FromRequest<(), B, M> + 'static,
        M: 'static;
    fn extract_with_state<E, S, M>(
        self,
        state: &S
    ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequest<S, B, M>>::Rejection>> + Send, Global>>
    where
        E: FromRequest<S, B, M> + 'static,
        S: Send + Sync;
    fn extract_parts<E>(
        &mut self
    ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequestParts<()>>::Rejection>> + Send, Global>>
    where
        E: FromRequestParts<()> + 'static;
    fn extract_parts_with_state<E, S, 'a>(
        &'a mut self,
        state: &'a S
    ) -> Pin<Box<dyn Future<Output = Result<E, <E as FromRequestParts<S>>::Rejection>> + Send + 'a, Global>>
    where
        E: FromRequestParts<S> + 'static,
        S: Send + Sync;
    fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>>;
    fn into_limited_body(self) -> Result<Limited<B>, B>;
}
Expand description

Extension trait that adds additional methods to Request.

Required Methods§

Apply an extractor to this Request.

This is just a convenience for E::from_request(req, &()).

Note this consumes the request. Use RequestExt::extract_parts if you’re not extracting the body and don’t want to consume the request.

Example
use axum::{
    async_trait,
    extract::FromRequest,
    http::{header::CONTENT_TYPE, Request, StatusCode},
    response::{IntoResponse, Response},
    Form, Json, RequestExt,
};

struct FormOrJson<T>(T);

#[async_trait]
impl<S, B, T> FromRequest<S, B> for FormOrJson<T>
where
    Json<T>: FromRequest<(), B>,
    Form<T>: FromRequest<(), B>,
    T: 'static,
    B: Send + 'static,
    S: Send + Sync,
{
    type Rejection = Response;

    async fn from_request(req: Request<B>, _state: &S) -> Result<Self, Self::Rejection> {
        let content_type = req
            .headers()
            .get(CONTENT_TYPE)
            .and_then(|value| value.to_str().ok())
            .ok_or_else(|| StatusCode::BAD_REQUEST.into_response())?;

        if content_type.starts_with("application/json") {
            let Json(payload) = req
                .extract::<Json<T>, _>()
                .await
                .map_err(|err| err.into_response())?;

            Ok(Self(payload))
        } else if content_type.starts_with("application/x-www-form-urlencoded") {
            let Form(payload) = req
                .extract::<Form<T>, _>()
                .await
                .map_err(|err| err.into_response())?;

            Ok(Self(payload))
        } else {
            Err(StatusCode::BAD_REQUEST.into_response())
        }
    }
}

Apply an extractor that requires some state to this Request.

This is just a convenience for E::from_request(req, state).

Note this consumes the request. Use RequestExt::extract_parts_with_state if you’re not extracting the body and don’t want to consume the request.

Example
use axum::{
    async_trait,
    extract::{FromRef, FromRequest},
    http::Request,
    RequestExt,
};

struct MyExtractor {
    requires_state: RequiresState,
}

#[async_trait]
impl<S, B> FromRequest<S, B> for MyExtractor
where
    String: FromRef<S>,
    S: Send + Sync,
    B: Send + 'static,
{
    type Rejection = std::convert::Infallible;

    async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
        let requires_state = req.extract_with_state::<RequiresState, _, _>(state).await?;

        Ok(Self { requires_state })
    }
}

// some extractor that consumes the request body and requires state
struct RequiresState { /* ... */ }

#[async_trait]
impl<S, B> FromRequest<S, B> for RequiresState
where
    String: FromRef<S>,
    S: Send + Sync,
    B: Send + 'static,
{
    // ...
}

Apply a parts extractor to this Request.

This is just a convenience for E::from_request_parts(parts, state).

Example
use axum::{
    async_trait,
    extract::FromRequest,
    headers::{authorization::Bearer, Authorization},
    http::Request,
    response::{IntoResponse, Response},
    Json, RequestExt, TypedHeader,
};

struct MyExtractor<T> {
    bearer_token: String,
    payload: T,
}

#[async_trait]
impl<S, B, T> FromRequest<S, B> for MyExtractor<T>
where
    B: Send + 'static,
    S: Send + Sync,
    Json<T>: FromRequest<(), B>,
    T: 'static,
{
    type Rejection = Response;

    async fn from_request(mut req: Request<B>, _state: &S) -> Result<Self, Self::Rejection> {
        let TypedHeader(auth_header) = req
            .extract_parts::<TypedHeader<Authorization<Bearer>>>()
            .await
            .map_err(|err| err.into_response())?;

        let Json(payload) = req
            .extract::<Json<T>, _>()
            .await
            .map_err(|err| err.into_response())?;

        Ok(Self {
            bearer_token: auth_header.token().to_owned(),
            payload,
        })
    }
}

Apply a parts extractor that requires some state to this Request.

This is just a convenience for E::from_request_parts(parts, state).

Example
use axum::{
    async_trait,
    extract::{FromRef, FromRequest, FromRequestParts},
    http::{request::Parts, Request},
    response::{IntoResponse, Response},
    Json, RequestExt,
};

struct MyExtractor<T> {
    requires_state: RequiresState,
    payload: T,
}

#[async_trait]
impl<S, B, T> FromRequest<S, B> for MyExtractor<T>
where
    String: FromRef<S>,
    Json<T>: FromRequest<(), B>,
    T: 'static,
    S: Send + Sync,
    B: Send + 'static,
{
    type Rejection = Response;

    async fn from_request(mut req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
        let requires_state = req
            .extract_parts_with_state::<RequiresState, _>(state)
            .await
            .map_err(|err| err.into_response())?;

        let Json(payload) = req
            .extract::<Json<T>, _>()
            .await
            .map_err(|err| err.into_response())?;

        Ok(Self {
            requires_state,
            payload,
        })
    }
}

struct RequiresState {}

#[async_trait]
impl<S> FromRequestParts<S> for RequiresState
where
    String: FromRef<S>,
    S: Send + Sync,
{
    // ...
}
source

fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>>

Apply the default body limit.

If it is disabled, return the request as-is in Err.

source

fn into_limited_body(self) -> Result<Limited<B>, B>

Consumes the request, returning the body wrapped in Limited if a default limit is in place, or not wrapped if the default limit is disabled.

Implementations on Foreign Types§

source§

fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>>

source§

fn into_limited_body(self) -> Result<Limited<B>, B>

Implementors§