Add rustapi-validate crate for validation support

Introduces the rustapi-validate crate, providing a validation system for the RustAPI framework. Includes error types, a Validate trait wrapping validator, and re-exports for easy integration. Implements standard error formats and comprehensive tests.

Author: Tuntii

crates/rustapi-validate/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "rustapi-validate"
+description = "Validation system for RustAPI framework"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+
+[dependencies]
+# Validation (internal - not exposed in public API)
+validator = { version = "0.18", features = ["derive"] }
+
+# Serialization
+serde = { workspace = true }
+serde_json = { workspace = true }
+
+# Error handling
+thiserror = { workspace = true }
+
+# HTTP types for response
+http = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/rustapi-validate/src/error.rs

@@ -0,0 +1,231 @@
+//! Validation error types and JSON error format.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt;
+
+/// A single field validation error.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FieldError {
+    /// The field name that failed validation
+    pub field: String,
+    /// The validation rule code (e.g., "email", "length", "range")
+    pub code: String,
+    /// Human-readable error message
+    pub message: String,
+    /// Optional additional parameters (e.g., min/max values)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub params: Option<HashMap<String, serde_json::Value>>,
+}
+
+impl FieldError {
+    /// Create a new field error.
+    pub fn new(field: impl Into<String>, code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            field: field.into(),
+            code: code.into(),
+            message: message.into(),
+            params: None,
+        }
+    }
+
+    /// Create a field error with parameters.
+    pub fn with_params(
+        field: impl Into<String>,
+        code: impl Into<String>,
+        message: impl Into<String>,
+        params: HashMap<String, serde_json::Value>,
+    ) -> Self {
+        Self {
+            field: field.into(),
+            code: code.into(),
+            message: message.into(),
+            params: Some(params),
+        }
+    }
+}
+
+/// Internal error structure for JSON serialization.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ErrorBody {
+    #[serde(rename = "type")]
+    error_type: String,
+    message: String,
+    fields: Vec<FieldError>,
+}
+
+/// Wrapper for the error response format.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ErrorWrapper {
+    error: ErrorBody,
+}
+
+/// Validation error containing all field errors.
+///
+/// This type serializes to the standard RustAPI error format:
+///
+/// ```json
+/// {
+///   "error": {
+///     "type": "validation_error",
+///     "message": "Validation failed",
+///     "fields": [...]
+///   }
+/// }
+/// ```
+#[derive(Debug, Clone)]
+pub struct ValidationError {
+    /// Collection of field-level validation errors
+    pub fields: Vec<FieldError>,
+    /// Custom error message (default: "Validation failed")
+    pub message: String,
+}
+
+impl ValidationError {
+    /// Create a new validation error with field errors.
+    pub fn new(fields: Vec<FieldError>) -> Self {
+        Self {
+            fields,
+            message: "Validation failed".to_string(),
+        }
+    }
+
+    /// Create a validation error with a custom message.
+    pub fn with_message(fields: Vec<FieldError>, message: impl Into<String>) -> Self {
+        Self {
+            fields,
+            message: message.into(),
+        }
+    }
+
+    /// Create a validation error for a single field.
+    pub fn field(field: impl Into<String>, code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self::new(vec![FieldError::new(field, code, message)])
+    }
+
+    /// Check if there are any validation errors.
+    pub fn is_empty(&self) -> bool {
+        self.fields.is_empty()
+    }
+
+    /// Get the number of field errors.
+    pub fn len(&self) -> usize {
+        self.fields.len()
+    }
+
+    /// Add a field error.
+    pub fn add(&mut self, error: FieldError) {
+        self.fields.push(error);
+    }
+
+    /// Convert validator errors to our format.
+    pub fn from_validator_errors(errors: validator::ValidationErrors) -> Self {
+        let mut field_errors = Vec::new();
+
+        for (field, error_kinds) in errors.field_errors() {
+            for error in error_kinds {
+                let code = error.code.to_string();
+                let message = error
+                    .message
+                    .as_ref()
+                    .map(|m| m.to_string())
+                    .unwrap_or_else(|| format!("Validation failed for field '{}'", field));
+
+                let params = if error.params.is_empty() {
+                    None
+                } else {
+                    let mut map = HashMap::new();
+                    for (key, value) in &error.params {
+                        if let Ok(json_value) = serde_json::to_value(value) {
+                            map.insert(key.to_string(), json_value);
+                        }
+                    }
+                    Some(map)
+                };
+
+                field_errors.push(FieldError {
+                    field: field.to_string(),
+                    code,
+                    message,
+                    params,
+                });
+            }
+        }
+
+        Self::new(field_errors)
+    }
+}
+
+impl fmt::Display for ValidationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {} field error(s)", self.message, self.fields.len())
+    }
+}
+
+impl std::error::Error for ValidationError {}
+
+impl Serialize for ValidationError {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let wrapper = ErrorWrapper {
+            error: ErrorBody {
+                error_type: "validation_error".to_string(),
+                message: self.message.clone(),
+                fields: self.fields.clone(),
+            },
+        };
+        wrapper.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for ValidationError {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let wrapper = ErrorWrapper::deserialize(deserializer)?;
+        Ok(Self {
+            fields: wrapper.error.fields,
+            message: wrapper.error.message,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn field_error_creation() {
+        let error = FieldError::new("email", "email", "Invalid email format");
+        assert_eq!(error.field, "email");
+        assert_eq!(error.code, "email");
+        assert_eq!(error.message, "Invalid email format");
+        assert!(error.params.is_none());
+    }
+
+    #[test]
+    fn validation_error_serialization() {
+        let error = ValidationError::new(vec![
+            FieldError::new("email", "email", "Invalid email format"),
+        ]);
+
+        let json = serde_json::to_value(&error).unwrap();
+        
+        assert_eq!(json["error"]["type"], "validation_error");
+        assert_eq!(json["error"]["message"], "Validation failed");
+        assert_eq!(json["error"]["fields"][0]["field"], "email");
+    }
+
+    #[test]
+    fn validation_error_display() {
+        let error = ValidationError::new(vec![
+            FieldError::new("email", "email", "Invalid email"),
+            FieldError::new("age", "range", "Out of range"),
+        ]);
+
+        assert_eq!(error.to_string(), "Validation failed: 2 field error(s)");
+    }
+}

crates/rustapi-validate/src/lib.rs

@@ -0,0 +1,84 @@
+//! # RustAPI Validation
+//!
+//! Validation system for RustAPI framework. Provides declarative validation
+//! on structs using the `#[derive(Validate)]` macro.
+//!
+//! ## Example
+//!
+//! ```rust
+//! use rustapi_validate::prelude::*;
+//!
+//! #[derive(Validate)]
+//! struct CreateUser {
+//!     #[validate(email)]
+//!     email: String,
+//!     
+//!     #[validate(length(min = 3, max = 50))]
+//!     username: String,
+//!     
+//!     #[validate(range(min = 18, max = 120))]
+//!     age: u8,
+//! }
+//! ```
+//!
+//! ## Validation Rules
+//!
+//! - `email` - Validates email format
+//! - `length(min = X, max = Y)` - String length validation
+//! - `range(min = X, max = Y)` - Numeric range validation
+//! - `regex = "..."` - Regex pattern validation
+//! - `non_empty` - Non-empty string/collection validation
+//! - `nested` - Validates nested structs
+//!
+//! ## Error Format
+//!
+//! Validation errors return a 422 Unprocessable Entity with JSON:
+//!
+//! ```json
+//! {
+//!   "error": {
+//!     "type": "validation_error",
+//!     "message": "Validation failed",
+//!     "fields": [
+//!       {"field": "email", "code": "email", "message": "Invalid email format"},
+//!       {"field": "age", "code": "range", "message": "Value must be between 18 and 120"}
+//!     ]
+//!   }
+//! }
+//! ```
+
+mod error;
+mod validate;
+
+pub use error::{FieldError, ValidationError};
+pub use validate::Validate;
+
+// Re-export the derive macro from validator (wrapped)
+// In a full implementation, we'd create our own proc-macro
+// For now, we use validator's derive with our own trait
+pub use validator::Validate as ValidatorValidate;
+
+/// Prelude module for validation
+pub mod prelude {
+    pub use crate::error::{FieldError, ValidationError};
+    pub use crate::validate::Validate;
+    pub use validator::Validate as ValidatorValidate;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn validation_error_to_json() {
+        let error = ValidationError::new(vec![
+            FieldError::new("email", "email", "Invalid email format"),
+            FieldError::new("age", "range", "Value must be between 18 and 120"),
+        ]);
+
+        let json = serde_json::to_string_pretty(&error).unwrap();
+        assert!(json.contains("validation_error"));
+        assert!(json.contains("email"));
+        assert!(json.contains("age"));
+    }
+}