Trait axum_core::RequestExt
source · pub trait RequestExt: Sealed + Sized {
// Required methods
fn extract<E, M>(self) -> BoxFuture<'static, Result<E, E::Rejection>>
where E: FromRequest<(), M> + 'static,
M: 'static;
fn extract_with_state<E, S, M>(
self,
state: &S,
) -> BoxFuture<'_, Result<E, E::Rejection>>
where E: FromRequest<S, M> + 'static,
S: Send + Sync;
fn extract_parts<E>(&mut self) -> BoxFuture<'_, Result<E, E::Rejection>>
where E: FromRequestParts<()> + 'static;
fn extract_parts_with_state<'a, E, S>(
&'a mut self,
state: &'a S,
) -> BoxFuture<'a, Result<E, E::Rejection>>
where E: FromRequestParts<S> + 'static,
S: Send + Sync;
fn with_limited_body(self) -> Request;
fn into_limited_body(self) -> Body;
}
Expand description
Extension trait that adds additional methods to Request
.
Required Methods§
sourcefn extract<E, M>(self) -> BoxFuture<'static, Result<E, E::Rejection>>where
E: FromRequest<(), M> + 'static,
M: 'static,
fn extract<E, M>(self) -> BoxFuture<'static, Result<E, E::Rejection>>where
E: FromRequest<(), M> + 'static,
M: 'static,
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::{Request, FromRequest},
body::Body,
http::{header::CONTENT_TYPE, StatusCode},
response::{IntoResponse, Response},
Form, Json, RequestExt,
};
struct FormOrJson<T>(T);
#[async_trait]
impl<S, T> FromRequest<S> for FormOrJson<T>
where
Json<T>: FromRequest<()>,
Form<T>: FromRequest<()>,
T: 'static,
S: Send + Sync,
{
type Rejection = Response;
async fn from_request(req: Request, _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())
}
}
}
sourcefn extract_with_state<E, S, M>(
self,
state: &S,
) -> BoxFuture<'_, Result<E, E::Rejection>>
fn extract_with_state<E, S, M>( self, state: &S, ) -> BoxFuture<'_, Result<E, E::Rejection>>
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,
body::Body,
extract::{Request, FromRef, FromRequest},
RequestExt,
};
struct MyExtractor {
requires_state: RequiresState,
}
#[async_trait]
impl<S> FromRequest<S> for MyExtractor
where
String: FromRef<S>,
S: Send + Sync,
{
type Rejection = std::convert::Infallible;
async fn from_request(req: Request, 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> FromRequest<S> for RequiresState
where
String: FromRef<S>,
S: Send + Sync,
{
// ...
}
sourcefn extract_parts<E>(&mut self) -> BoxFuture<'_, Result<E, E::Rejection>>where
E: FromRequestParts<()> + 'static,
fn extract_parts<E>(&mut self) -> BoxFuture<'_, Result<E, E::Rejection>>where
E: FromRequestParts<()> + '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::{Path, Request, FromRequest},
response::{IntoResponse, Response},
body::Body,
Json, RequestExt,
};
use axum_extra::{
TypedHeader,
headers::{authorization::Bearer, Authorization},
};
use std::collections::HashMap;
struct MyExtractor<T> {
path_params: HashMap<String, String>,
payload: T,
}
#[async_trait]
impl<S, T> FromRequest<S> for MyExtractor<T>
where
S: Send + Sync,
Json<T>: FromRequest<()>,
T: 'static,
{
type Rejection = Response;
async fn from_request(mut req: Request, _state: &S) -> Result<Self, Self::Rejection> {
let path_params = req
.extract_parts::<Path<_>>()
.await
.map(|Path(path_params)| path_params)
.map_err(|err| err.into_response())?;
let Json(payload) = req
.extract::<Json<T>, _>()
.await
.map_err(|err| err.into_response())?;
Ok(Self { path_params, payload })
}
}
sourcefn extract_parts_with_state<'a, E, S>(
&'a mut self,
state: &'a S,
) -> BoxFuture<'a, Result<E, E::Rejection>>
fn extract_parts_with_state<'a, E, S>( &'a mut self, state: &'a S, ) -> BoxFuture<'a, Result<E, E::Rejection>>
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::{Request, FromRef, FromRequest, FromRequestParts},
http::request::Parts,
response::{IntoResponse, Response},
body::Body,
Json, RequestExt,
};
struct MyExtractor<T> {
requires_state: RequiresState,
payload: T,
}
#[async_trait]
impl<S, T> FromRequest<S> for MyExtractor<T>
where
String: FromRef<S>,
Json<T>: FromRequest<()>,
T: 'static,
S: Send + Sync,
{
type Rejection = Response;
async fn from_request(mut req: Request, 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,
{
// ...
}
sourcefn with_limited_body(self) -> Request
fn with_limited_body(self) -> Request
Apply the default body limit.
If it is disabled, the request is returned as-is.
sourcefn into_limited_body(self) -> Body
fn into_limited_body(self) -> Body
Consumes the request, returning the body wrapped in http_body_util::Limited
if a
default limit is in place, or not wrapped if the
default limit is disabled.