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

examples/customize-extractor-error/src/custom_extractor.rs

@@ -4,15 +4,13 @@
 //!   and `async/await`. This means that you can create more powerful rejections
 //! - Boilerplate: Requires creating a new extractor for every custom rejection
 //! - Complexity: Manually implementing `FromRequest` results on more complex code
-use axum::extract::MatchedPath;
 use axum::{
     async_trait,
-    extract::{rejection::JsonRejection, FromRequest, RequestParts},
+    extract::{rejection::JsonRejection, FromRequest, FromRequestParts, MatchedPath},
+    http::Request,
     http::StatusCode,
     response::IntoResponse,
-    BoxError,
 };
-use serde::de::DeserializeOwned;
 use serde_json::{json, Value};
 
 pub async fn handler(Json(value): Json<Value>) -> impl IntoResponse {
@@ -25,31 +23,33 @@ pub struct Json<T>(pub T);
 #[async_trait]
 impl<S, B, T> FromRequest<S, B> for Json<T>
 where
+    axum::Json<T>: FromRequest<S, B, Rejection = JsonRejection>,
     S: Send + Sync,
-    // these trait bounds are copied from `impl FromRequest for axum::Json`
-    // `T: Send` is required to send this future across an await
-    T: DeserializeOwned + Send,
-    B: axum::body::HttpBody + Send,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
+    B: Send + 'static,
 {
     type Rejection = (StatusCode, axum::Json<Value>);
 
-    async fn from_request(req: &mut RequestParts<S, B>) -> Result<Self, Self::Rejection> {
-        match axum::Json::<T>::from_request(req).await {
+    async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
+        let (mut parts, body) = req.into_parts();
+
+        // We can use other extractors to provide better rejection
+        // messages. For example, here we are using
+        // `axum::extract::MatchedPath` to provide a better error
+        // message
+        //
+        // Have to run that first since `Json::from_request` consumes
+        // the request
+        let path = MatchedPath::from_request_parts(&mut parts, state)
+            .await
+            .map(|path| path.as_str().to_owned())
+            .ok();
+
+        let req = Request::from_parts(parts, body);
+
+        match axum::Json::<T>::from_request(req, state).await {
             Ok(value) => Ok(Self(value.0)),
             // convert the error from `axum::Json` into whatever we want
             Err(rejection) => {
-                let path = req
-                    .extract::<MatchedPath>()
-                    .await
-                    .map(|x| x.as_str().to_owned())
-                    .ok();
-
-                // We can use other extractors to provide better rejection
-                // messages. For example, here we are using
-                // `axum::extract::MatchedPath` to provide a better error
-                // message
                 let payload = json!({
                     "message": rejection.to_string(),
                     "origin": "custom_extractor",

examples/customize-extractor-error/src/derive_from_request.rs

@@ -47,7 +47,7 @@ impl From<JsonRejection> for ApiError {
     }
 }
 
-// We implement `IntoResponse` so ApiError can be used as a response
+// We implement `IntoResponse` so `ApiError` can be used as a response
 impl IntoResponse for ApiError {
     fn into_response(self) -> axum::response::Response {
         let payload = json!({