115 lines
3.4 KiB
Rust
115 lines
3.4 KiB
Rust
//! Custom extractor for automatic JSON validation and sanitization
|
|
//!
|
|
//! This extractor automatically validates request payloads using the validator crate
|
|
//! and returns appropriate error responses if validation fails.
|
|
|
|
use axum::{
|
|
extract::{rejection::JsonRejection, FromRequest, Request},
|
|
http::StatusCode,
|
|
response::{IntoResponse, Response},
|
|
Json,
|
|
};
|
|
use serde::de::DeserializeOwned;
|
|
use serde_json;
|
|
use validator::Validate;
|
|
|
|
/// Custom extractor that automatically validates JSON payloads
|
|
///
|
|
/// # Example
|
|
/// ```rust
|
|
/// use imphnen_libs::axum::ValidatedJson;
|
|
/// use axum::response::Response;
|
|
/// use axum::body::Body;
|
|
/// use serde::Deserialize;
|
|
/// use validator::Validate;
|
|
///
|
|
/// #[derive(Deserialize, Validate)]
|
|
/// struct CreateUserRequest {
|
|
/// #[validate(email)]
|
|
/// email: String,
|
|
/// #[validate(length(min = 8))]
|
|
/// password: String,
|
|
/// }
|
|
///
|
|
/// async fn create_user(
|
|
/// ValidatedJson(payload): ValidatedJson<CreateUserRequest>
|
|
/// ) -> Response {
|
|
/// // payload is already validated
|
|
/// // ... your logic here
|
|
/// Response::new(Body::from("ok"))
|
|
/// }
|
|
/// ```
|
|
pub struct ValidatedJson<T>(pub T);
|
|
|
|
impl<T, S> FromRequest<S> for ValidatedJson<T>
|
|
where
|
|
T: DeserializeOwned + Validate + 'static,
|
|
S: Send + Sync,
|
|
Json<T>: FromRequest<S, Rejection = JsonRejection>,
|
|
{
|
|
type Rejection = Response;
|
|
|
|
async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
|
|
// First, extract JSON
|
|
let Json(value) = match Json::<T>::from_request(req, state).await {
|
|
Ok(value) => value,
|
|
Err(rejection) => {
|
|
let error_message = format!("Invalid JSON payload: {rejection}");
|
|
return Err((
|
|
StatusCode::BAD_REQUEST,
|
|
Json(serde_json::json!({
|
|
"error": error_message,
|
|
"version": env!("CARGO_PKG_VERSION"),
|
|
})),
|
|
)
|
|
.into_response());
|
|
}
|
|
};
|
|
|
|
// Then, validate it
|
|
if let Err(errors) = value.validate() {
|
|
let error_messages: Vec<String> = errors
|
|
.field_errors()
|
|
.iter()
|
|
.flat_map(|(field, errors)| {
|
|
errors.iter().map(move |error| {
|
|
format!(
|
|
"{}: {}",
|
|
field,
|
|
error.message.as_ref().map(|m| m.to_string()).unwrap_or_else(|| error.code.to_string())
|
|
)
|
|
})
|
|
})
|
|
.collect();
|
|
|
|
return Err((
|
|
StatusCode::BAD_REQUEST,
|
|
Json(serde_json::json!({
|
|
"error": "Validation failed",
|
|
"details": error_messages,
|
|
"version": env!("CARGO_PKG_VERSION"),
|
|
})),
|
|
)
|
|
.into_response());
|
|
}
|
|
|
|
Ok(ValidatedJson(value))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde::Deserialize;
|
|
|
|
#[derive(Debug, Deserialize, Validate)]
|
|
struct TestPayload {
|
|
#[validate(email)]
|
|
email: String,
|
|
#[validate(length(min = 8))]
|
|
password: String,
|
|
}
|
|
|
|
// Note: Full integration tests should be done at the application level
|
|
}
|