Provide more data in Path deserialization error (#574)

* Provide more error in `Path` deserialization error * Rename * Add error kind for deserializing sequences * Rename * Fix wrong docs * Rename `MissingRouteParams` * Rename error to have more consistency * Rename internal error * Update changelog * One last renaming, for now * Add tests * Tweak changelog a bit
2026-08-25 00:00:23 +02:00 · 2021-12-02 08:51:29 +01:00
parent 66c5142d0c
commit 3ec680cce7
8 changed files with 658 additions and 137 deletions
@@ -0,0 +1,144 @@
+//! Run with
+//!
+//! ```not_rust
+//! cargo run -p example-customize-path-rejection
+//! ```
+
+use axum::{
+    async_trait,
+    extract::{path::ErrorKind, rejection::PathRejection, FromRequest, RequestParts},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::get,
+    Router,
+};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use std::net::SocketAddr;
+
+#[tokio::main]
+async fn main() {
+    // Set the RUST_LOG, if it hasn't been explicitly defined
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "example_customize_path_rejection=debug")
+    }
+    tracing_subscriber::fmt::init();
+
+    // build our application with a route
+    let app = Router::new().route("/users/:user_id/teams/:team_id", get(handler));
+
+    // run it
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    println!("listening on {}", addr);
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+}
+
+async fn handler(Path(params): Path<Params>) -> impl IntoResponse {
+    axum::Json(params)
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Params {
+    user_id: u32,
+    team_id: u32,
+}
+
+// We define our own `Path` extractor that customizes the error from `axum::extract::Path`
+struct Path<T>(T);
+
+#[async_trait]
+impl<B, T> FromRequest<B> for Path<T>
+where
+    // these trait bounds are copied from `impl FromRequest for axum::extract::path::Path`
+    T: DeserializeOwned + Send,
+    B: Send,
+{
+    type Rejection = (StatusCode, axum::Json<PathError>);
+
+    async fn from_request(req: &mut RequestParts<B>) -> Result<Self, Self::Rejection> {
+        match axum::extract::Path::<T>::from_request(req).await {
+            Ok(value) => Ok(Self(value.0)),
+            Err(rejection) => {
+                let (status, body) = match rejection {
+                    PathRejection::FailedToDeserializePathParams(inner) => {
+                        let mut status = StatusCode::BAD_REQUEST;
+
+                        let kind = inner.into_kind();
+                        let body = match &kind {
+                            ErrorKind::WrongNumberOfParameters { .. } => PathError {
+                                message: kind.to_string(),
+                                location: None,
+                            },
+
+                            ErrorKind::ParseErrorAtKey { key, .. } => PathError {
+                                message: kind.to_string(),
+                                location: Some(key.clone()),
+                            },
+
+                            ErrorKind::ParseErrorAtIndex { index, .. } => PathError {
+                                message: kind.to_string(),
+                                location: Some(index.to_string()),
+                            },
+
+                            ErrorKind::ParseError { .. } => PathError {
+                                message: kind.to_string(),
+                                location: None,
+                            },
+
+                            ErrorKind::InvalidUtf8InPathParam { key } => PathError {
+                                message: kind.to_string(),
+                                location: Some(key.clone()),
+                            },
+
+                            ErrorKind::UnsupportedType { .. } => {
+                                // this error is caused by the programmer using an unsupported type
+                                // (such as nested maps) so respond with `500` instead
+                                status = StatusCode::INTERNAL_SERVER_ERROR;
+                                PathError {
+                                    message: kind.to_string(),
+                                    location: None,
+                                }
+                            }
+
+                            ErrorKind::Message(msg) => PathError {
+                                message: msg.clone(),
+                                location: None,
+                            },
+
+                            _ => PathError {
+                                message: format!("Unhandled deserialization error: {}", kind),
+                                location: None,
+                            },
+                        };
+
+                        (status, body)
+                    }
+                    PathRejection::MissingPathParams(error) => (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        PathError {
+                            message: error.to_string(),
+                            location: None,
+                        },
+                    ),
+                    _ => (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        PathError {
+                            message: format!("Unhandled path rejection: {}", rejection),
+                            location: None,
+                        },
+                    ),
+                };
+
+                Err((status, axum::Json(body)))
+            }
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct PathError {
+    message: String,
+    location: Option<String>,
+}