Crate axum_validated_extractors 

A collection of validated extractors for Axum

This crate provides a set of extractors for Axum that automatically validate the extracted data using the validator crate.

Features

• ValidatedForm: Validates form data (URL-encoded or multipart)
• ValidatedJson: Validates JSON data
• ValidatedQuery: Validates query parameters
• Automatic validation using the validator crate
• Type-safe error handling

Examples

Basic Usage

use axum::{
    routing::post,
    Router,
};
use axum_validated_extractors::{ValidatedJson, ValidatedForm, ValidatedQuery};
use serde::Deserialize;
use validator::Validate;

#[derive(Debug, Deserialize, Validate)]
struct CreateUser {
    #[validate(length(min = 3))]
    username: String,
    #[validate(email)]
    email: String,
}

async fn create_user(
    ValidatedJson(user): ValidatedJson<CreateUser>,
) {
    // user is guaranteed to be valid
    println!("Creating user: {:?}", user);
}

let app: Router<()> = Router::new()
    .route("/users", post(create_user));

Form Data

use axum::{
    routing::post,
    Router,
};
use axum_validated_extractors::ValidatedForm;
use serde::Deserialize;
use validator::Validate;

#[derive(Debug, Deserialize, Validate)]
struct LoginForm {
    #[validate(length(min = 3))]
    username: String,
    #[validate(length(min = 8))]
    password: String,
}

async fn login(
    ValidatedForm(form): ValidatedForm<LoginForm>,
) {
    // form is guaranteed to be valid
    println!("Logging in user: {:?}", form);
}

let app: Router<()> = Router::new()
    .route("/login", post(login));

Query Parameters

use axum::{
    routing::get,
    Router,
};
use axum_validated_extractors::ValidatedQuery;
use serde::Deserialize;
use validator::Validate;

#[derive(Debug, Deserialize, Validate)]
struct SearchParams {
    #[validate(length(min = 2))]
    query: String,
    #[validate(range(min = 1, max = 100))]
    page: Option<u32>,
}

async fn search(
    ValidatedQuery(params): ValidatedQuery<SearchParams>,
) {
    // params is guaranteed to be valid
    println!("Searching with params: {:?}", params);
}

let app: Router<()> = Router::new()
    .route("/search", get(search));

Error Handling

use axum::{
    routing::post,
    Router,
    response::IntoResponse,
    Json,
};
use axum_validated_extractors::{ValidatedJson, ValidationError};
use serde::{Deserialize, Serialize};
use validator::Validate;

#[derive(Debug, Deserialize, Serialize, Validate)]
struct CreateUser {
    #[validate(length(min = 3))]
    username: String,
    #[validate(email)]
    email: String,
}

async fn create_user(
    ValidatedJson(user): ValidatedJson<CreateUser>,
) -> impl IntoResponse {
    // If validation fails, a 400 Bad Request response is returned
    // with a detailed error message
    Json(user)
}

let app: Router<()> = Router::new()
    .route("/users", post(create_user));

Structs

ValidatedForm

Validated form data extractor

ValidatedJson

Validated JSON data extractor

ValidatedQuery

Validated query parameters extractor

Enums

ValidationError

Error type for validated extractors