tokio-rs/axum
1
0
Fork 0
mirror of https://github.com/tokio-rs/axum.git synced 2026-08-29 00:00:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Only allow last extractor to mutate the request (#1272)

Browse Source 
* Only allow last extractor to mutate the request

* Change `FromRequest` and add `FromRequestParts` trait (#1275)

* Add `Once`/`Mut` type parameter for `FromRequest` and `RequestParts`

* 🪄

* split traits

* `FromRequest` for tuples

* Remove `BodyAlreadyExtracted`

* don't need fully qualified path

* don't export `Once` and `Mut`

* remove temp tests

* depend on axum again

Co-authored-by: Jonas Platte <[email protected]>

* Port `Handler` and most extractors (#1277)

* Port `Handler` and most extractors

* Put `M` inside `Handler` impls, not trait itself

* comment out tuples for now

* fix lints

* Reorder arguments to `Handler` (#1281)

I think `Request<B>, Arc<S>` is better since its consistent with
`FromRequest` and `FromRequestParts`.

* Port most things in axum-extra (#1282)

* Port `#[derive(TypedPath)]` and `#[debug_handler]` (#1283)

* port #[derive(TypedPath)]

* wip: #[debug_handler]

* fix #[debug_handler]

* don't need itertools

* also require `Send`

* update expected error

* support fully qualified `self`

* Implement FromRequest[Parts] for tuples (#1286)

* Port docs for axum and axum-core (#1285)

* Port axum-extra (#1287)

* Port axum-extra

* Update axum-core/Cargo.toml

Co-authored-by: Jonas Platte <[email protected]>

* remove `impl FromRequest for Either*`

Co-authored-by: Jonas Platte <[email protected]>

* New FromRequest[Parts] trait cleanup (#1288)

* Make private module truly private again

* Simplify tuple FromRequest implementation

* Port `#[derive(FromRequest)]` (#1289)

* fix tests

* fix docs

* revert examples

* fix docs link

* fix intra docs links

* Port examples (#1291)

* Document wrapping other extractors (#1292)

* axum-extra doesn't need to depend on axum-core (#1294)

Missed this in https://github.com/tokio-rs/axum/pull/1287

* Add `FromRequest` changes to changelogs (#1293)

* Update changelog

* Remove default type for `S` in `Handler`

* Clarify which types have default types for `S`

* Apply suggestions from code review

Co-authored-by: Jonas Platte <[email protected]>

Co-authored-by: Jonas Platte <[email protected]>

* remove unused import

* Rename `Mut` and `Once` (#1296)

* fix trybuild expected output

Co-authored-by: Jonas Platte <[email protected]>
This commit is contained in:
David Pedersen
2022-08-22 12:23:20 +02:00
committed by GitHub
co-authored by Jonas Platte
parent f1769e5134
commit be624306f4
104 changed files with 1513 additions and 1936 deletions
Download Patch File Download Diff File Expand all files Collapse all files
axum-extra/src/either.rs
+48 -13
View File
@@ -4,15 +4,50 @@
//!
//! ```
//! use axum_extra::either::Either3;
//! use axum::{body::Bytes, Json};
//! use axum::{
//! body::Bytes,
//! Router,
//! async_trait,
//! routing::get,
//! extract::FromRequestParts,
//! };
//!
//! // extractors for checking permissions
//! struct AdminPermissions {}
//!
//! #[async_trait]
//! impl<S> FromRequestParts<S> for AdminPermissions
//! where
//! S: Send + Sync,
//! {
//! // check for admin permissions...
//! # type Rejection = ();
//! # async fn from_request_parts(parts: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
//! # todo!()
//! # }
//! }
//!
//! struct User {}
//!
//! #[async_trait]
//! impl<S> FromRequestParts<S> for User
//! where
//! S: Send + Sync,
//! {
//! // check for a logged in user...
//! # type Rejection = ();
//! # async fn from_request_parts(parts: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
//! # todo!()
//! # }
//! }
//!
//! async fn handler(
//! body: Either3<Json<serde_json::Value>, String, Bytes>,
//! body: Either3<AdminPermissions, User, ()>,
//! ) {
//! match body {
//! Either3::E1(json) => { /* ... */ }
//! Either3::E2(string) => { /* ... */ }
//! Either3::E3(bytes) => { /* ... */ }
//! Either3::E1(admin) => { /* ... */ }
//! Either3::E2(user) => { /* ... */ }
//! Either3::E3(guest) => { /* ... */ }
//! }
//! }
//! #
@@ -60,9 +95,10 @@
use axum::{
async_trait,
extract::{FromRequest, RequestParts},
extract::FromRequestParts,
response::{IntoResponse, Response},
};
use http::request::Parts;
/// Combines two extractors or responses into a single type.
///
@@ -190,23 +226,22 @@ macro_rules! impl_traits_for_either {
$last:ident $(,)?
) => {
#[async_trait]
impl<S, B, $($ident),*, $last> FromRequest<S, B> for $either<$($ident),*, $last>
impl<S, $($ident),*, $last> FromRequestParts<S> for $either<$($ident),*, $last>
where
$($ident: FromRequest<S, B>),*,
$last: FromRequest<S, B>,
B: Send,
$($ident: FromRequestParts<S>),*,
$last: FromRequestParts<S>,
S: Send + Sync,
{
type Rejection = $last::Rejection;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
$(
if let Ok(value) = req.extract().await {
if let Ok(value) = FromRequestParts::from_request_parts(parts, state).await {
return Ok(Self::$ident(value));
}
)*
req.extract().await.map(Self::$last)
FromRequestParts::from_request_parts(parts, state).await.map(Self::$last)
}
}
axum-extra/src/extract/cached.rs
+53 -23
View File
@@ -1,7 +1,8 @@
use axum::{
async_trait,
extract::{Extension, FromRequest, RequestParts},
extract::{Extension, FromRequest, FromRequestParts},
};
use http::{request::Parts, Request};
use std::ops::{Deref, DerefMut};
/// Cache results of other extractors.
@@ -20,24 +21,23 @@ use std::ops::{Deref, DerefMut};
/// use axum_extra::extract::Cached;
/// use axum::{
/// async_trait,
/// extract::{FromRequest, RequestParts},
/// extract::FromRequestParts,
/// body::BoxBody,
/// response::{IntoResponse, Response},
/// http::StatusCode,
/// http::{StatusCode, request::Parts},
/// };
///
/// #[derive(Clone)]
/// struct Session { /* ... */ }
///
/// #[async_trait]
/// impl<S, B> FromRequest<S, B> for Session
/// impl<S> FromRequestParts<S> for Session
/// where
/// B: Send,
/// S: Send + Sync,
/// {
/// type Rejection = (StatusCode, String);
///
/// async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
/// async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
/// // load session...
/// # unimplemented!()
/// }
@@ -46,19 +46,18 @@ use std::ops::{Deref, DerefMut};
/// struct CurrentUser { /* ... */ }
///
/// #[async_trait]
/// impl<S, B> FromRequest<S, B> for CurrentUser
/// impl<S> FromRequestParts<S> for CurrentUser
/// where
/// B: Send,
/// S: Send + Sync,
/// {
/// type Rejection = Response;
///
/// async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
/// async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
/// // loading a `CurrentUser` requires first loading the `Session`
/// //
/// // by using `Cached<Session>` we avoid extracting the session more than
/// // once, in case other extractors for the same request also loads the session
/// let session: Session = Cached::<Session>::from_request(req)
/// let session: Session = Cached::<Session>::from_request_parts(parts, state)
/// .await
/// .map_err(|err| err.into_response())?
/// .0;
@@ -92,18 +91,40 @@ struct CachedEntry<T>(T);
#[async_trait]
impl<S, B, T> FromRequest<S, B> for Cached<T>
where
B: Send,
B: Send + 'static,
S: Send + Sync,
T: FromRequest<S, B> + Clone + Send + Sync + 'static,
T: FromRequestParts<S> + Clone + Send + Sync + 'static,
{
type Rejection = T::Rejection;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
match Extension::<CachedEntry<T>>::from_request(req).await {
async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
let (mut parts, _) = req.into_parts();
match Extension::<CachedEntry<T>>::from_request_parts(&mut parts, state).await {
Ok(Extension(CachedEntry(value))) => Ok(Self(value)),
Err(_) => {
let value = T::from_request(req).await?;
req.extensions_mut().insert(CachedEntry(value.clone()));
let value = T::from_request_parts(&mut parts, state).await?;
parts.extensions.insert(CachedEntry(value.clone()));
Ok(Self(value))
}
}
}
}
#[async_trait]
impl<S, T> FromRequestParts<S> for Cached<T>
where
S: Send + Sync,
T: FromRequestParts<S> + Clone + Send + Sync + 'static,
{
type Rejection = T::Rejection;
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
match Extension::<CachedEntry<T>>::from_request_parts(parts, state).await {
Ok(Extension(CachedEntry(value))) => Ok(Self(value)),
Err(_) => {
let value = T::from_request_parts(parts, state).await?;
parts.extensions.insert(CachedEntry(value.clone()));
Ok(Self(value))
}
}
@@ -127,7 +148,8 @@ impl<T> DerefMut for Cached<T> {
#[cfg(test)]
mod tests {
use super::*;
use axum::http::Request;
use axum::{extract::FromRequestParts, http::Request};
use http::request::Parts;
use std::{
convert::Infallible,
sync::atomic::{AtomicU32, Ordering},
@@ -142,25 +164,33 @@ mod tests {
struct Extractor(Instant);
#[async_trait]
impl<S, B> FromRequest<S, B> for Extractor
impl<S> FromRequestParts<S> for Extractor
where
B: Send,
S: Send + Sync,
{
type Rejection = Infallible;
async fn from_request(_req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
async fn from_request_parts(
_parts: &mut Parts,
_state: &S,
) -> Result<Self, Self::Rejection> {
COUNTER.fetch_add(1, Ordering::SeqCst);
Ok(Self(Instant::now()))
}
}
let mut req = RequestParts::new(Request::new(()));
let (mut parts, _) = Request::new(()).into_parts();
let first = Cached::<Extractor>::from_request(&mut req).await.unwrap().0;
let first = Cached::<Extractor>::from_request_parts(&mut parts, &())
.await
.unwrap()
.0;
assert_eq!(COUNTER.load(Ordering::SeqCst), 1);
let second = Cached::<Extractor>::from_request(&mut req).await.unwrap().0;
let second = Cached::<Extractor>::from_request_parts(&mut parts, &())
.await
.unwrap()
.0;
assert_eq!(COUNTER.load(Ordering::SeqCst), 1);
assert_eq!(first, second);
axum-extra/src/extract/cookie/mod.rs
+11 -7
View File
@@ -4,11 +4,12 @@
use axum::{
async_trait,
extract::{FromRequest, RequestParts},
extract::FromRequestParts,
response::{IntoResponse, IntoResponseParts, Response, ResponseParts},
};
use http::{
header::{COOKIE, SET_COOKIE},
request::Parts,
HeaderMap,
};
use std::convert::Infallible;
@@ -88,15 +89,14 @@ pub struct CookieJar {
}
#[async_trait]
impl<S, B> FromRequest<S, B> for CookieJar
impl<S> FromRequestParts<S> for CookieJar
where
B: Send,
S: Send + Sync,
{
type Rejection = Infallible;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
Ok(Self::from_headers(req.headers()))
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
Ok(Self::from_headers(&parts.headers))
}
}
@@ -115,7 +115,9 @@ impl CookieJar {
/// The cookies in `headers` will be added to the jar.
///
/// This is inteded to be used in middleware and other places where it might be difficult to
/// run extractors. Normally you should create `CookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `CookieJar`s through [`FromRequestParts`].
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn from_headers(headers: &HeaderMap) -> Self {
let mut jar = cookie::CookieJar::new();
for cookie in cookies_from_request(headers) {
@@ -127,10 +129,12 @@ impl CookieJar {
/// Create a new empty `CookieJar`.
///
/// This is inteded to be used in middleware and other places where it might be difficult to
/// run extractors. Normally you should create `CookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `CookieJar`s through [`FromRequestParts`].
///
/// If you need a jar that contains the headers from a request use `impl From<&HeaderMap> for
/// CookieJar`.
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn new() -> Self {
Self::default()
}
axum-extra/src/extract/cookie/private.rs
+12 -9
View File
@@ -1,11 +1,11 @@
use super::{cookies_from_request, set_cookies, Cookie, Key};
use axum::{
async_trait,
extract::{FromRef, FromRequest, RequestParts},
extract::{FromRef, FromRequestParts},
response::{IntoResponse, IntoResponseParts, Response, ResponseParts},
};
use cookie::PrivateJar;
use http::HeaderMap;
use http::{request::Parts, HeaderMap};
use std::{convert::Infallible, fmt, marker::PhantomData};
/// Extractor that grabs private cookies from the request and manages the jar.
@@ -87,22 +87,21 @@ impl<K> fmt::Debug for PrivateCookieJar<K> {
}
#[async_trait]
impl<S, B, K> FromRequest<S, B> for PrivateCookieJar<K>
impl<S, K> FromRequestParts<S> for PrivateCookieJar<K>
where
B: Send,
S: Send + Sync,
K: FromRef<S> + Into<Key>,
{
type Rejection = Infallible;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
let k = K::from_ref(req.state());
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
let k = K::from_ref(state);
let key = k.into();
let PrivateCookieJar {
jar,
key,
_marker: _,
} = PrivateCookieJar::from_headers(req.headers(), key);
} = PrivateCookieJar::from_headers(&parts.headers, key);
Ok(PrivateCookieJar {
jar,
key,
@@ -117,7 +116,9 @@ impl PrivateCookieJar {
/// The valid cookies in `headers` will be added to the jar.
///
/// This is inteded to be used in middleware and other where places it might be difficult to
/// run extractors. Normally you should create `PrivateCookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `PrivateCookieJar`s through [`FromRequestParts`].
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn from_headers(headers: &HeaderMap, key: Key) -> Self {
let mut jar = cookie::CookieJar::new();
let mut private_jar = jar.private_mut(&key);
@@ -137,7 +138,9 @@ impl PrivateCookieJar {
/// Create a new empty `PrivateCookieJarIter`.
///
/// This is inteded to be used in middleware and other places where it might be difficult to
/// run extractors. Normally you should create `PrivateCookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `PrivateCookieJar`s through [`FromRequestParts`].
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn new(key: Key) -> Self {
Self {
jar: Default::default(),
axum-extra/src/extract/cookie/signed.rs
+12 -9
View File
@@ -1,12 +1,12 @@
use super::{cookies_from_request, set_cookies};
use axum::{
async_trait,
extract::{FromRef, FromRequest, RequestParts},
extract::{FromRef, FromRequestParts},
response::{IntoResponse, IntoResponseParts, Response, ResponseParts},
};
use cookie::SignedJar;
use cookie::{Cookie, Key};
use http::HeaderMap;
use http::{request::Parts, HeaderMap};
use std::{convert::Infallible, fmt, marker::PhantomData};
/// Extractor that grabs signed cookies from the request and manages the jar.
@@ -105,22 +105,21 @@ impl<K> fmt::Debug for SignedCookieJar<K> {
}
#[async_trait]
impl<S, B, K> FromRequest<S, B> for SignedCookieJar<K>
impl<S, K> FromRequestParts<S> for SignedCookieJar<K>
where
B: Send,
S: Send + Sync,
K: FromRef<S> + Into<Key>,
{
type Rejection = Infallible;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
let k = K::from_ref(req.state());
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
let k = K::from_ref(state);
let key = k.into();
let SignedCookieJar {
jar,
key,
_marker: _,
} = SignedCookieJar::from_headers(req.headers(), key);
} = SignedCookieJar::from_headers(&parts.headers, key);
Ok(SignedCookieJar {
jar,
key,
@@ -135,7 +134,9 @@ impl SignedCookieJar {
/// The valid cookies in `headers` will be added to the jar.
///
/// This is inteded to be used in middleware and other places where it might be difficult to
/// run extractors. Normally you should create `SignedCookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `SignedCookieJar`s through [`FromRequestParts`].
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn from_headers(headers: &HeaderMap, key: Key) -> Self {
let mut jar = cookie::CookieJar::new();
let mut signed_jar = jar.signed_mut(&key);
@@ -155,7 +156,9 @@ impl SignedCookieJar {
/// Create a new empty `SignedCookieJar`.
///
/// This is inteded to be used in middleware and other places where it might be difficult to
/// run extractors. Normally you should create `SignedCookieJar`s through [`FromRequest`].
/// run extractors. Normally you should create `SignedCookieJar`s through [`FromRequestParts`].
///
/// [`FromRequestParts`]: axum::extract::FromRequestParts
pub fn new(key: Key) -> Self {
Self {
jar: Default::default(),
axum-extra/src/extract/form.rs
+8 -8
View File
@@ -3,12 +3,12 @@ use axum::{
body::HttpBody,
extract::{
rejection::{FailedToDeserializeQueryString, FormRejection, InvalidFormContentType},
FromRequest, RequestParts,
FromRequest,
},
BoxError,
};
use bytes::Bytes;
use http::{header, Method};
use http::{header, HeaderMap, Method, Request};
use serde::de::DeserializeOwned;
use std::ops::Deref;
@@ -58,25 +58,25 @@ impl<T> Deref for Form<T> {
impl<T, S, B> FromRequest<S, B> for Form<T>
where
T: DeserializeOwned,
B: HttpBody + Send,
B: HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<BoxError>,
S: Send + Sync,
{
type Rejection = FormRejection;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
if req.method() == Method::GET {
let query = req.uri().query().unwrap_or_default();
let value = serde_html_form::from_str(query)
.map_err(FailedToDeserializeQueryString::__private_new)?;
Ok(Form(value))
} else {
if !has_content_type(req, &mime::APPLICATION_WWW_FORM_URLENCODED) {
if !has_content_type(req.headers(), &mime::APPLICATION_WWW_FORM_URLENCODED) {
return Err(InvalidFormContentType::default().into());
}
let bytes = Bytes::from_request(req).await?;
let bytes = Bytes::from_request(req, state).await?;
let value = serde_html_form::from_bytes(&bytes)
.map_err(FailedToDeserializeQueryString::__private_new)?;
@@ -86,8 +86,8 @@ where
}
// this is duplicated in `axum/src/extract/mod.rs`
fn has_content_type<S, B>(req: &RequestParts<S, B>, expected_content_type: &mime::Mime) -> bool {
let content_type = if let Some(content_type) = req.headers().get(header::CONTENT_TYPE) {
fn has_content_type(headers: &HeaderMap, expected_content_type: &mime::Mime) -> bool {
let content_type = if let Some(content_type) = headers.get(header::CONTENT_TYPE) {
content_type
} else {
return false;
axum-extra/src/extract/query.rs
+5 -5
View File
@@ -2,9 +2,10 @@ use axum::{
async_trait,
extract::{
rejection::{FailedToDeserializeQueryString, QueryRejection},
FromRequest, RequestParts,
FromRequestParts,
},
};
use http::request::Parts;
use serde::de::DeserializeOwned;
use std::ops::Deref;
@@ -58,16 +59,15 @@ use std::ops::Deref;
pub struct Query<T>(pub T);
#[async_trait]
impl<T, S, B> FromRequest<S, B> for Query<T>
impl<T, S> FromRequestParts<S> for Query<T>
where
T: DeserializeOwned,
B: Send,
S: Send + Sync,
{
type Rejection = QueryRejection;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
let query = req.uri().query().unwrap_or_default();
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
let query = parts.uri.query().unwrap_or_default();
let value = serde_html_form::from_str(query)
.map_err(FailedToDeserializeQueryString::__private_new)?;
Ok(Query(value))
axum-extra/src/extract/with_rejection.rs
+36 -13
View File
@@ -1,6 +1,8 @@
use axum::async_trait;
use axum::extract::{FromRequest, RequestParts};
use axum::extract::{FromRequest, FromRequestParts};
use axum::response::IntoResponse;
use http::request::Parts;
use http::Request;
use std::fmt::Debug;
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
@@ -109,23 +111,40 @@ impl<E, R> DerefMut for WithRejection<E, R> {
#[async_trait]
impl<B, E, R, S> FromRequest<S, B> for WithRejection<E, R>
where
B: Send,
B: Send + 'static,
S: Send + Sync,
E: FromRequest<S, B>,
R: From<E::Rejection> + IntoResponse,
{
type Rejection = R;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
let extractor = req.extract::<E>().await?;
async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
let extractor = E::from_request(req, state).await?;
Ok(WithRejection(extractor, PhantomData))
}
}
#[async_trait]
impl<E, R, S> FromRequestParts<S> for WithRejection<E, R>
where
S: Send + Sync,
E: FromRequestParts<S>,
R: From<E::Rejection> + IntoResponse,
{
type Rejection = R;
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
let extractor = E::from_request_parts(parts, state).await?;
Ok(WithRejection(extractor, PhantomData))
}
}
#[cfg(test)]
mod tests {
use axum::extract::FromRequestParts;
use axum::http::Request;
use axum::response::Response;
use http::request::Parts;
use super::*;
@@ -135,14 +154,16 @@ mod tests {
struct TestRejection;
#[async_trait]
impl<S, B> FromRequest<S, B> for TestExtractor
impl<S> FromRequestParts<S> for TestExtractor
where
B: Send,
S: Send + Sync,
{
type Rejection = ();
async fn from_request(_: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
async fn from_request_parts(
_parts: &mut Parts,
_state: &S,
) -> Result<Self, Self::Rejection> {
Err(())
}
}
@@ -159,12 +180,14 @@ mod tests {
}
}
let mut req = RequestParts::new(Request::new(()));
let req = Request::new(());
let result = WithRejection::<TestExtractor, TestRejection>::from_request(req, &()).await;
assert!(matches!(result, Err(TestRejection)));
let result = req
.extract::<WithRejection<TestExtractor, TestRejection>>()
.await;
assert!(matches!(result, Err(TestRejection)))
let (mut parts, _) = Request::new(()).into_parts();
let result =
WithRejection::<TestExtractor, TestRejection>::from_request_parts(&mut parts, &())
.await;
assert!(matches!(result, Err(TestRejection)));
}
}
axum-extra/src/handler/mod.rs
+30 -33
View File
@@ -1,7 +1,7 @@
//! Additional handler utilities.
use axum::{
extract::{FromRequest, RequestParts},
extract::FromRequest,
handler::Handler,
response::{IntoResponse, Response},
};
@@ -26,8 +26,8 @@ pub trait HandlerCallWithExtractors<T, S, B>: Sized {
/// Call the handler with the extracted inputs.
fn call(
self,
state: Arc<S>,
extractors: T,
state: Arc<S>,
) -> <Self as HandlerCallWithExtractors<T, S, B>>::Future;
/// Conver this `HandlerCallWithExtractors` into [`Handler`].
@@ -51,7 +51,7 @@ pub trait HandlerCallWithExtractors<T, S, B>: Sized {
/// Router,
/// async_trait,
/// routing::get,
/// extract::FromRequest,
/// extract::FromRequestParts,
/// };
///
/// // handlers for varying levels of access
@@ -71,14 +71,13 @@ pub trait HandlerCallWithExtractors<T, S, B>: Sized {
/// struct AdminPermissions {}
///
/// #[async_trait]
/// impl<S, B> FromRequest<S, B> for AdminPermissions
/// impl<S> FromRequestParts<S> for AdminPermissions
/// where
/// B: Send,
/// S: Send + Sync,
/// {
/// // check for admin permissions...
/// # type Rejection = ();
/// # async fn from_request(req: &mut axum::extract::RequestParts<S, B>) -> Result<Self, Self::Rejection> {
/// # async fn from_request_parts(parts: &mut http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
/// # todo!()
/// # }
/// }
@@ -86,14 +85,13 @@ pub trait HandlerCallWithExtractors<T, S, B>: Sized {
/// struct User {}
///
/// #[async_trait]
/// impl<S, B> FromRequest<S, B> for User
/// impl<S> FromRequestParts<S> for User
/// where
/// B: Send,
/// S: Send + Sync,
/// {
/// // check for a logged in user...
/// # type Rejection = ();
/// # async fn from_request(req: &mut axum::extract::RequestParts<S, B>) -> Result<Self, Self::Rejection> {
/// # async fn from_request_parts(parts: &mut http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
/// # todo!()
/// # }
/// }
@@ -121,27 +119,27 @@ pub trait HandlerCallWithExtractors<T, S, B>: Sized {
}
macro_rules! impl_handler_call_with {
( $($ty:ident),* $(,)? ) => {
#[allow(non_snake_case)]
impl<F, Fut, S, B, $($ty,)*> HandlerCallWithExtractors<($($ty,)*), S, B> for F
where
F: FnOnce($($ty,)*) -> Fut,
Fut: Future + Send + 'static,
Fut::Output: IntoResponse,
{
// this puts `futures_util` in our public API but thats fine in axum-extra
type Future = Map<Fut, fn(Fut::Output) -> Response>;
( $($ty:ident),* $(,)? ) => {
#[allow(non_snake_case)]
impl<F, Fut, S, B, $($ty,)*> HandlerCallWithExtractors<($($ty,)*), S, B> for F
where
F: FnOnce($($ty,)*) -> Fut,
Fut: Future + Send + 'static,
Fut::Output: IntoResponse,
{
// this puts `futures_util` in our public API but thats fine in axum-extra
type Future = Map<Fut, fn(Fut::Output) -> Response>;
fn call(
self,
_state: Arc<S>,
($($ty,)*): ($($ty,)*),
) -> <Self as HandlerCallWithExtractors<($($ty,)*), S, B>>::Future {
self($($ty,)*).map(IntoResponse::into_response)
}
}
};
}
fn call(
self,
($($ty,)*): ($($ty,)*),
_state: Arc<S>,
) -> <Self as HandlerCallWithExtractors<($($ty,)*), S, B>>::Future {
self($($ty,)*).map(IntoResponse::into_response)
}
}
};
}
impl_handler_call_with!();
impl_handler_call_with!(T1);
@@ -180,11 +178,10 @@ where
{
type Future = BoxFuture<'static, Response>;
fn call(self, state: Arc<S>, req: http::Request<B>) -> Self::Future {
fn call(self, req: http::Request<B>, state: Arc<S>) -> Self::Future {
Box::pin(async move {
let mut req = RequestParts::with_state_arc(Arc::clone(&state), req);
match req.extract::<T>().await {
Ok(t) => self.handler.call(state, t).await,
match T::from_request(req, &state).await {
Ok(t) => self.handler.call(t, state).await,
Err(rejection) => rejection.into_response(),
}
})
axum-extra/src/handler/or.rs
+16 -16
View File
@@ -1,13 +1,12 @@
use super::HandlerCallWithExtractors;
use crate::either::Either;
use axum::{
extract::{FromRequest, RequestParts},
extract::{FromRequest, FromRequestParts},
handler::Handler,
http::Request,
response::{IntoResponse, Response},
};
use futures_util::future::{BoxFuture, Either as EitherFuture, FutureExt, Map};
use http::StatusCode;
use std::{future::Future, marker::PhantomData, sync::Arc};
/// [`Handler`] that runs one [`Handler`] and if that rejects it'll fallback to another
@@ -37,30 +36,30 @@ where
fn call(
self,
state: Arc<S>,
extractors: Either<Lt, Rt>,
state: Arc<S>,
) -> <Self as HandlerCallWithExtractors<Either<Lt, Rt>, S, B>>::Future {
match extractors {
Either::E1(lt) => self
.lhs
.call(state, lt)
.call(lt, state)
.map(IntoResponse::into_response as _)
.left_future(),
Either::E2(rt) => self
.rhs
.call(state, rt)
.call(rt, state)
.map(IntoResponse::into_response as _)
.right_future(),
}
}
}
impl<S, B, L, R, Lt, Rt> Handler<(Lt, Rt), S, B> for Or<L, R, Lt, Rt, S, B>
impl<S, B, L, R, Lt, Rt, M> Handler<(M, Lt, Rt), S, B> for Or<L, R, Lt, Rt, S, B>
where
L: HandlerCallWithExtractors<Lt, S, B> + Clone + Send + 'static,
R: HandlerCallWithExtractors<Rt, S, B> + Clone + Send + 'static,
Lt: FromRequest<S, B> + Send + 'static,
Rt: FromRequest<S, B> + Send + 'static,
Lt: FromRequestParts<S> + Send + 'static,
Rt: FromRequest<S, B, M> + Send + 'static,
Lt::Rejection: Send,
Rt::Rejection: Send,
B: Send + 'static,
@@ -69,19 +68,20 @@ where
// this puts `futures_util` in our public API but thats fine in axum-extra
type Future = BoxFuture<'static, Response>;
fn call(self, state: Arc<S>, req: Request<B>) -> Self::Future {
fn call(self, req: Request<B>, state: Arc<S>) -> Self::Future {
Box::pin(async move {
let mut req = RequestParts::with_state_arc(Arc::clone(&state), req);
let (mut parts, body) = req.into_parts();
if let Ok(lt) = req.extract::<Lt>().await {
return self.lhs.call(state, lt).await;
if let Ok(lt) = Lt::from_request_parts(&mut parts, &state).await {
return self.lhs.call(lt, state).await;
}
if let Ok(rt) = req.extract::<Rt>().await {
return self.rhs.call(state, rt).await;
}
let req = Request::from_parts(parts, body);
StatusCode::NOT_FOUND.into_response()
match Rt::from_request(req, &state).await {
Ok(rt) => self.rhs.call(rt, state).await,
Err(rejection) => rejection.into_response(),
}
})
}
}
axum-extra/src/json_lines.rs
+8 -6
View File
@@ -3,15 +3,17 @@
use axum::{
async_trait,
body::{HttpBody, StreamBody},
extract::{rejection::BodyAlreadyExtracted, FromRequest, RequestParts},
extract::FromRequest,
response::{IntoResponse, Response},
BoxError,
};
use bytes::{BufMut, Bytes, BytesMut};
use futures_util::stream::{BoxStream, Stream, TryStream, TryStreamExt};
use http::Request;
use pin_project_lite::pin_project;
use serde::{de::DeserializeOwned, Serialize};
use std::{
convert::Infallible,
io::{self, Write},
marker::PhantomData,
pin::Pin,
@@ -106,14 +108,14 @@ where
T: DeserializeOwned,
S: Send + Sync,
{
type Rejection = BodyAlreadyExtracted;
type Rejection = Infallible;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
async fn from_request(req: Request<B>, _state: &S) -> Result<Self, Self::Rejection> {
// `Stream::lines` isn't a thing so we have to convert it into an `AsyncRead`
// so we can call `AsyncRead::lines` and then convert it back to a `Stream`
let body = req.take_body().ok_or_else(BodyAlreadyExtracted::default)?;
let body = BodyStream { body };
let body = BodyStream {
body: req.into_body(),
};
let stream = body
.map_ok(Into::into)
axum-extra/src/protobuf.rs
+5 -5
View File
@@ -3,12 +3,12 @@
use axum::{
async_trait,
body::{Bytes, HttpBody},
extract::{rejection::BytesRejection, FromRequest, RequestParts},
extract::{rejection::BytesRejection, FromRequest},
response::{IntoResponse, Response},
BoxError,
};
use bytes::BytesMut;
use http::StatusCode;
use http::{Request, StatusCode};
use prost::Message;
use std::ops::{Deref, DerefMut};
@@ -100,15 +100,15 @@ pub struct ProtoBuf<T>(pub T);
impl<T, S, B> FromRequest<S, B> for ProtoBuf<T>
where
T: Message + Default,
B: HttpBody + Send,
B: HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<BoxError>,
S: Send + Sync,
{
type Rejection = ProtoBufRejection;
async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
let mut bytes = Bytes::from_request(req).await?;
async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
let mut bytes = Bytes::from_request(req, state).await?;
match T::decode(&mut bytes) {
Ok(value) => Ok(ProtoBuf(value)),
axum-extra/src/routing/mod.rs
+17 -17
View File
@@ -24,7 +24,7 @@ pub use self::resource::Resource;
pub use axum_macros::TypedPath;
#[cfg(feature = "typed-routing")]
pub use self::typed::{FirstElementIs, TypedPath};
pub use self::typed::{SecondElementIs, TypedPath};
#[cfg(feature = "spa")]
pub use self::spa::SpaRouter;
@@ -41,7 +41,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_get<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `DELETE` route to the router.
@@ -54,7 +54,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_delete<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `HEAD` route to the router.
@@ -67,7 +67,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_head<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `OPTIONS` route to the router.
@@ -80,7 +80,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_options<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `PATCH` route to the router.
@@ -93,7 +93,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_patch<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `POST` route to the router.
@@ -106,7 +106,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_post<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `PUT` route to the router.
@@ -119,7 +119,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_put<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add a typed `TRACE` route to the router.
@@ -132,7 +132,7 @@ pub trait RouterExt<S, B>: sealed::Sealed {
fn typed_trace<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath;
/// Add another route to the router with an additional "trailing slash redirect" route.
@@ -184,7 +184,7 @@ where
fn typed_get<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::get(handler))
@@ -194,7 +194,7 @@ where
fn typed_delete<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::delete(handler))
@@ -204,7 +204,7 @@ where
fn typed_head<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::head(handler))
@@ -214,7 +214,7 @@ where
fn typed_options<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::options(handler))
@@ -224,7 +224,7 @@ where
fn typed_patch<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::patch(handler))
@@ -234,7 +234,7 @@ where
fn typed_post<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::post(handler))
@@ -244,7 +244,7 @@ where
fn typed_put<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::put(handler))
@@ -254,7 +254,7 @@ where
fn typed_trace<H, T, P>(self, handler: H) -> Self
where
H: Handler<T, S, B>,
T: FirstElementIs<P> + 'static,
T: SecondElementIs<P> + 'static,
P: TypedPath,
{
self.route(P::PATH, axum::routing::trace(handler))
axum-extra/src/routing/typed.rs
+27 -27
View File
@@ -231,10 +231,10 @@ pub trait TypedPath: std::fmt::Display {
}
}
/// Utility trait used with [`RouterExt`] to ensure the first element of a tuple type is a
/// Utility trait used with [`RouterExt`] to ensure the second element of a tuple type is a
/// given type.
///
/// If you see it in type errors its most likely because the first argument to your handler doesn't
/// If you see it in type errors its most likely because the second argument to your handler doesn't
/// implement [`TypedPath`].
///
/// You normally shouldn't have to use this trait directly.
@@ -242,56 +242,56 @@ pub trait TypedPath: std::fmt::Display {
/// It is sealed such that it cannot be implemented outside this crate.
///
/// [`RouterExt`]: super::RouterExt
pub trait FirstElementIs<P>: Sealed {}
pub trait SecondElementIs<P>: Sealed {}
macro_rules! impl_first_element_is {
macro_rules! impl_second_element_is {
( $($ty:ident),* $(,)? ) => {
impl<P, $($ty,)*> FirstElementIs<P> for (P, $($ty,)*)
impl<M, P, $($ty,)*> SecondElementIs<P> for (M, P, $($ty,)*)
where
P: TypedPath
{}
impl<P, $($ty,)*> Sealed for (P, $($ty,)*)
impl<M, P, $($ty,)*> Sealed for (M, P, $($ty,)*)
where
P: TypedPath
{}
impl<P, $($ty,)*> FirstElementIs<P> for (Option<P>, $($ty,)*)
impl<M, P, $($ty,)*> SecondElementIs<P> for (M, Option<P>, $($ty,)*)
where
P: TypedPath
{}
impl<P, $($ty,)*> Sealed for (Option<P>, $($ty,)*)
impl<M, P, $($ty,)*> Sealed for (M, Option<P>, $($ty,)*)
where
P: TypedPath
{}
impl<P, E, $($ty,)*> FirstElementIs<P> for (Result<P, E>, $($ty,)*)
impl<M, P, E, $($ty,)*> SecondElementIs<P> for (M, Result<P, E>, $($ty,)*)
where
P: TypedPath
{}
impl<P, E, $($ty,)*> Sealed for (Result<P, E>, $($ty,)*)
impl<M, P, E, $($ty,)*> Sealed for (M, Result<P, E>, $($ty,)*)
where
P: TypedPath
{}
};
}
impl_first_element_is!();
impl_first_element_is!(T1);
impl_first_element_is!(T1, T2);
impl_first_element_is!(T1, T2, T3);
impl_first_element_is!(T1, T2, T3, T4);
impl_first_element_is!(T1, T2, T3, T4, T5);
impl_first_element_is!(T1, T2, T3, T4, T5, T6);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
impl_first_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
impl_second_element_is!();
impl_second_element_is!(T1);
impl_second_element_is!(T1, T2);
impl_second_element_is!(T1, T2, T3);
impl_second_element_is!(T1, T2, T3, T4);
impl_second_element_is!(T1, T2, T3, T4, T5);
impl_second_element_is!(T1, T2, T3, T4, T5, T6);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
impl_second_element_is!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);