Request Validation

use axum::Json;
use serde::Deserialize;
use validator::{Validate, ValidationError};
 
#[derive(Debug, Deserialize, Validate)]
struct SignupRequest {
    #[validate(email)]
    email: String,
    #[validate(length(min = 8))]
    password: String,
}
 
async fn signup(Json(body): Json<SignupRequest>) -> Result<(), AppError> {
    body.validate().map_err(AppError::from)?;
    // business logic
    Ok(())
}

use axum::{routing::post, Json, Router};
use serde::Deserialize;
use validator::{Validate, ValidationError};
 
#[derive(Deserialize, Validate)]
struct CreateUser {
    #[validate(email(message = "invalid email"))]
    email: String,
    #[validate(length(min = 2, max = 50))]
    display_name: String,
    #[validate(range(min = 18, max = 120))]
    age: u8,
}
 
#[derive(serde::Serialize)]
struct ErrorBody { fields: Vec<String> }
 
enum AppError { Validation(Vec<String>) }
 
impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        match self {
            AppError::Validation(fields) => (
                axum::http::StatusCode::UNPROCESSABLE_ENTITY,
                Json(ErrorBody { fields }),
            ).into_response(),
        }
    }
}
 
async fn create_user(Json(body): Json<CreateUser>) -> Result<&'static str, AppError> {
    body.validate().map_err(|e| {
        AppError::Validation(e.field_errors().keys().map(|k| k.to_string()).collect())
    })?;
    Ok("created")
}
 
#[tokio::main]
async fn main() {
    let app = Router::new().route("/users", post(create_user));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

fn check_reserved(name: &str) -> Result<(), ValidationError> {
    if name == "admin" {
        return Err(ValidationError::new("reserved"));
    }
    Ok(())
}
 
#[validate(custom(function = "check_reserved"))]
username: String,