Show the errored path on JsonDataError

Previously, it was difficult to find out the path in the deep JSON tree at
which a deserialization error occurred.  This patch makes an error message
to contain the errored path.  In order to find out the path,
I added serde_path_to_error, a new optional dependency.

Co-authored-by: Lee Dogeon <dev.moreal@gmail.com>

axum/Cargo.toml

@@ -16,7 +16,7 @@ default = ["form", "http1", "json", "matched-path", "original-uri", "query", "to
 form = ["dep:serde_urlencoded"]
 http1 = ["hyper/http1"]
 http2 = ["hyper/http2"]
-json = ["dep:serde_json"]
+json = ["dep:serde_json", "dep:serde_path_to_error"]
 macros = ["dep:axum-macros"]
 matched-path = []
 multipart = ["dep:multer"]
@@ -57,6 +57,7 @@ base64 = { version = "0.13", optional = true }
 headers = { version = "0.3.7", optional = true }
 multer = { version = "2.0.0", optional = true }
 serde_json = { version = "1.0", features = ["raw_value"], optional = true }
+serde_path_to_error = { version = "0.1.8", optional = true }
 serde_urlencoded = { version = "0.7", optional = true }
 sha-1 = { version = "0.10", optional = true }
 tokio-tungstenite = { version = "0.17.2", optional = true }

axum/src/json.rs

@@ -113,11 +113,12 @@ where
     async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
         if json_content_type(req.headers()) {
             let bytes = Bytes::from_request(req, state).await?;
+            let deserializer = &mut serde_json::Deserializer::from_slice(&bytes);
 
-            let value = match serde_json::from_slice(&bytes) {
+            let value = match serde_path_to_error::deserialize(deserializer) {
                 Ok(value) => value,
                 Err(err) => {
-                    let rejection = match err.classify() {
+                    let rejection = match err.inner().classify() {
                         serde_json::error::Category::Data => JsonDataError::from_err(err).into(),
                         serde_json::error::Category::Syntax | serde_json::error::Category::Eof => {
                             JsonSyntaxError::from_err(err).into()
@@ -296,4 +297,37 @@ mod tests {
 
         assert_eq!(res.status(), StatusCode::BAD_REQUEST);
     }
+
+    #[derive(Deserialize)]
+    struct Foo {
+        #[allow(dead_code)]
+        a: i32,
+        #[allow(dead_code)]
+        b: Vec<Bar>,
+    }
+
+    #[derive(Deserialize)]
+    struct Bar {
+        #[allow(dead_code)]
+        x: i32,
+        #[allow(dead_code)]
+        y: i32,
+    }
+
+    #[tokio::test]
+    async fn invalid_json_data() {
+        let app = Router::new().route("/", post(|_: Json<Foo>| async {}));
+
+        let client = TestClient::new(app);
+        let res = client
+            .post("/")
+            .body("{\"a\": 1, \"b\": [{\"x\": 2}]}")
+            .header("content-type", "application/json")
+            .send()
+            .await;
+
+        assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
+        let body_text = res.text().await;
+        assert!(body_text.contains("b[0]"), "body: {:?}", body_text);
+    }
 }