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

* 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]>

axum-extra/src/extract/cached.rs

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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)));
     }
 }