1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
//! Run with
//!
//! ```not_rust
//! cargo run -p example-customize-path-rejection
//! ```
use axum::{
async_trait,
extract::{path::ErrorKind, rejection::PathRejection, FromRequestParts},
http::{request::Parts, StatusCode},
response::IntoResponse,
routing::get,
Router,
};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::net::SocketAddr;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
#[tokio::main]
async fn main() {
tracing_subscriber::registry()
.with(
tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| "example_customize_path_rejection=debug".into()),
)
.with(tracing_subscriber::fmt::layer())
.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<S, T> FromRequestParts<S> for Path<T>
where
// these trait bounds are copied from `impl FromRequest for axum::extract::path::Path`
T: DeserializeOwned + Send,
S: Send + Sync,
{
type Rejection = (StatusCode, axum::Json<PathError>);
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
match axum::extract::Path::<T>::from_request_parts(parts, state).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>,
}
|
