Add unified validation system with async support

Introduces a unified Validatable trait to support both legacy validator and new v2 validation engines, including async validation. Adds AsyncValidatedJson extractor for async validation scenarios, updates extractors and prelude, and provides conversion helpers for error normalization. Updates documentation and adds comprehensive tests for sync and async validation flows.

Author: Tuntii

Cargo.lock

@@ -21,7 +21,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.15"
+version = "0.1.188"
 edition = "2021"
 authors = ["RustAPI Contributors"]
 license = "MIT OR Apache-2.0"
@@ -100,16 +100,16 @@ indicatif = "0.17"
 console = "0.15"
 
 # Internal crates
-rustapi-core = { path = "crates/rustapi-core", version = "0.1.15", default-features = false }
-rustapi-macros = { path = "crates/rustapi-macros", version = "0.1.15" }
-rustapi-validate = { path = "crates/rustapi-validate", version = "0.1.15" }
-rustapi-openapi = { path = "crates/rustapi-openapi", version = "0.1.15", default-features = false }
-rustapi-extras = { path = "crates/rustapi-extras", version = "0.1.15" }
-rustapi-toon = { path = "crates/rustapi-toon", version = "0.1.15" }
-rustapi-ws = { path = "crates/rustapi-ws", version = "0.1.15" }
-rustapi-view = { path = "crates/rustapi-view", version = "0.1.15" }
-rustapi-testing = { path = "crates/rustapi-testing", version = "0.1.15" }
-rustapi-jobs = { path = "crates/rustapi-jobs", version = "0.1.15" }
+rustapi-core = { path = "crates/rustapi-core", version = "0.1.188", default-features = false }
+rustapi-macros = { path = "crates/rustapi-macros", version = "0.1.188" }
+rustapi-validate = { path = "crates/rustapi-validate", version = "0.1.188" }
+rustapi-openapi = { path = "crates/rustapi-openapi", version = "0.1.188", default-features = false }
+rustapi-extras = { path = "crates/rustapi-extras", version = "0.1.188" }
+rustapi-toon = { path = "crates/rustapi-toon", version = "0.1.188" }
+rustapi-ws = { path = "crates/rustapi-ws", version = "0.1.188" }
+rustapi-view = { path = "crates/rustapi-view", version = "0.1.188" }
+rustapi-testing = { path = "crates/rustapi-testing", version = "0.1.188" }
+rustapi-jobs = { path = "crates/rustapi-jobs", version = "0.1.188" }
 
 # HTTP/3 (QUIC)
 quinn = "0.11"

Cargo.toml

@@ -56,6 +56,7 @@ brotli = { version = "6.0", optional = true }
 cookie = { version = "0.18", optional = true }
 
 # Validation
+validator = { workspace = true }
 rustapi-validate = { workspace = true }
 
 # Metrics (optional)
@@ -95,3 +96,4 @@ simd-json = ["dep:simd-json"]
 tracing = []
 http3 = ["dep:quinn", "dep:h3", "dep:h3-quinn", "dep:rustls", "dep:rustls-pemfile"]
 http3-dev = ["http3", "dep:rcgen"]
+

crates/rustapi-core/Cargo.toml

@@ -59,8 +59,10 @@ use crate::json;
 use crate::request::Request;
 use crate::response::IntoResponse;
 use crate::stream::{StreamingBody, StreamingConfig};
+use crate::validation::Validatable;
 use bytes::Bytes;
 use http::{header, StatusCode};
+use rustapi_validate::v2::{AsyncValidate, ValidationContext};
 
 use serde::de::DeserializeOwned;
 use serde::Serialize;
@@ -253,7 +255,7 @@ impl<T> ValidatedJson<T> {
     }
 }
 
-impl<T: DeserializeOwned + rustapi_validate::Validate + Send> FromRequest for ValidatedJson<T> {
+impl<T: DeserializeOwned + Validatable + Send> FromRequest for ValidatedJson<T> {
     async fn from_request(req: &mut Request) -> Result<Self> {
         req.load_body().await?;
         // First, deserialize the JSON body using simd-json when available
@@ -263,10 +265,9 @@ impl<T: DeserializeOwned + rustapi_validate::Validate + Send> FromRequest for Va
 
         let value: T = json::from_slice(&body)?;
 
-        // Then, validate it
-        if let Err(validation_error) = rustapi_validate::Validate::validate(&value) {
-            // Convert validation error to API error with 422 status
-            return Err(validation_error.into());
+        // Then, validate it using the unified Validatable trait
+        if let Err(e) = value.do_validate() {
+            return Err(e);
         }
 
         Ok(ValidatedJson(value))
@@ -299,6 +300,110 @@ impl<T: Serialize> IntoResponse for ValidatedJson<T> {
     }
 }
 
+/// Async validated JSON body extractor
+///
+/// Parses the request body as JSON, deserializes into type `T`, and validates
+/// using the `AsyncValidate` trait from `rustapi-validate`.
+///
+/// This extractor supports async validation rules, such as database uniqueness checks.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use rustapi_rs::prelude::*;
+/// use rustapi_validate::v2::prelude::*;
+///
+/// #[derive(Deserialize, Validate, AsyncValidate)]
+/// struct CreateUser {
+///     #[validate(email)]
+///     email: String,
+///     
+///     #[validate(async_unique(table = "users", column = "email"))]
+///     username: String,
+/// }
+///
+/// async fn register(AsyncValidatedJson(body): AsyncValidatedJson<CreateUser>) -> impl IntoResponse {
+///     // body is validated asynchronously (e.g. checked existing email in DB)
+/// }
+/// ```
+#[derive(Debug, Clone, Copy, Default)]
+pub struct AsyncValidatedJson<T>(pub T);
+
+impl<T> AsyncValidatedJson<T> {
+    /// Create a new AsyncValidatedJson wrapper
+    pub fn new(value: T) -> Self {
+        Self(value)
+    }
+
+    /// Get the inner value
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T> Deref for AsyncValidatedJson<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for AsyncValidatedJson<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> From<T> for AsyncValidatedJson<T> {
+    fn from(value: T) -> Self {
+        AsyncValidatedJson(value)
+    }
+}
+
+impl<T: Serialize> IntoResponse for AsyncValidatedJson<T> {
+    fn into_response(self) -> crate::response::Response {
+        Json(self.0).into_response()
+    }
+}
+
+impl<T: DeserializeOwned + AsyncValidate + Send + Sync> FromRequest for AsyncValidatedJson<T> {
+    async fn from_request(req: &mut Request) -> Result<Self> {
+        req.load_body().await?;
+
+        let body = req
+            .take_body()
+            .ok_or_else(|| ApiError::internal("Body already consumed"))?;
+
+        let value: T = json::from_slice(&body)?;
+
+        // Create validation context from request
+        // TODO: Extract validators from App State
+        let ctx = ValidationContext::default();
+
+        // Perform full validation (sync + async)
+        if let Err(errors) = value.validate_full(&ctx).await {
+            // Convert v2 ValidationErrors to ApiError
+            let field_errors: Vec<crate::error::FieldError> = errors
+                .fields
+                .iter()
+                .flat_map(|(field, errs)| {
+                    let field_name = field.to_string();
+                    errs.iter().map(move |e| crate::error::FieldError {
+                        field: field_name.clone(),
+                        code: e.code.to_string(),
+                        message: e.message.clone(),
+                    })
+                })
+                .collect();
+
+            return Err(ApiError::validation(field_errors));
+        }
+
+        Ok(AsyncValidatedJson(value))
+    }
+}
+
 /// Query string extractor
 ///
 /// Parses the query string into type `T`.

crates/rustapi-core/src/extract.rs

@@ -76,6 +76,7 @@ pub mod sse;
 pub mod static_files;
 pub mod stream;
 pub mod typed_path;
+pub mod validation;
 #[macro_use]
 mod tracing_macros;
 
@@ -97,8 +98,8 @@ pub use error::{get_environment, ApiError, Environment, FieldError, Result};
 #[cfg(feature = "cookies")]
 pub use extract::Cookies;
 pub use extract::{
-    Body, BodyStream, ClientIp, Extension, FromRequest, FromRequestParts, HeaderValue, Headers,
-    Json, Path, Query, State, Typed, ValidatedJson,
+    AsyncValidatedJson, Body, BodyStream, ClientIp, Extension, FromRequest, FromRequestParts,
+    HeaderValue, Headers, Json, Path, Query, State, Typed, ValidatedJson,
 };
 pub use handler::{
     delete_route, get_route, patch_route, post_route, put_route, Handler, HandlerService, Route,
@@ -125,3 +126,4 @@ pub use sse::{sse_response, KeepAlive, Sse, SseEvent};
 pub use static_files::{serve_dir, StaticFile, StaticFileConfig};
 pub use stream::{StreamBody, StreamingBody, StreamingConfig};
 pub use typed_path::TypedPath;
+pub use validation::Validatable;