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/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(),