use crate::error::{Error, Result};
use regex::Regex;
use serde_json::Value;
use std::collections::HashMap;
use std::sync::Arc;
pub type ValidationResult = Result<()>;
pub trait Validator: Send + Sync {
fn validate(&self, value: &Value, options: Option<&Value>) -> ValidationResult;
fn name(&self) -> &str {
"unnamed"
}
fn description(&self) -> &str {
"No description available"
}
}
struct FunctionValidator<F>
where
F: Fn(&Value, Option<&Value>) -> ValidationResult + Send + Sync,
{
func: F,
name: String,
description: String,
}
impl<F> Validator for FunctionValidator<F>
where
F: Fn(&Value, Option<&Value>) -> ValidationResult + Send + Sync,
{
fn validate(&self, value: &Value, options: Option<&Value>) -> ValidationResult {
(self.func)(value, options)
}
fn name(&self) -> &str {
&self.name
}
fn description(&self) -> &str {
&self.description
}
}
pub struct ValidatorRegistry {
validators: HashMap<String, Arc<dyn Validator>>,
}
impl std::fmt::Debug for ValidatorRegistry {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ValidatorRegistry")
.field("validator_count", &self.validators.len())
.field(
"validator_names",
&self.validators.keys().collect::<Vec<_>>(),
)
.finish()
}
}
impl ValidatorRegistry {
pub fn new() -> Self {
let mut registry = Self {
validators: HashMap::new(),
};
registry.register_builtin_validators();
registry
}
pub fn register(&mut self, name: &str, validator: impl Validator + 'static) {
log::debug!("Registering validator: {}", name);
self.validators
.insert(name.to_string(), Arc::new(validator));
}
pub fn register_fn<F>(&mut self, name: &str, description: &str, func: F)
where
F: Fn(&Value, Option<&Value>) -> ValidationResult + Send + Sync + 'static,
{
let validator = FunctionValidator {
func,
name: name.to_string(),
description: description.to_string(),
};
self.register(name, validator);
}
pub fn get(&self, name: &str) -> Option<Arc<dyn Validator>> {
self.validators.get(name).cloned()
}
pub fn exists(&self, name: &str) -> bool {
self.validators.contains_key(name)
}
pub fn count(&self) -> usize {
self.validators.len()
}
pub fn list(&self) -> Vec<String> {
self.validators.keys().cloned().collect()
}
pub fn validate(
&self,
validator_name: &str,
value: &Value,
options: Option<&Value>,
) -> ValidationResult {
match self.validators.get(validator_name) {
Some(validator) => validator.validate(value, options),
None => Err(Error::internal(format!(
"Validator '{}' not found",
validator_name
))),
}
}
fn register_builtin_validators(&mut self) {
self.register_fn(
"required",
"Value must not be null or empty",
|value, _| match value {
Value::Null => Err(Error::validation("Value is required")),
Value::String(s) if s.is_empty() => Err(Error::validation("Value is required")),
Value::Array(a) if a.is_empty() => Err(Error::validation("Value is required")),
_ => Ok(()),
},
);
self.register("email", EmailValidator);
self.register("url", UrlValidator);
self.register("phone", PhoneValidator);
self.register("credit_card", CreditCardValidator);
self.register_fn(
"min_length",
"Minimum length validation",
|value, options| {
let min = options
.and_then(|o| o.get("min"))
.and_then(|v| v.as_u64())
.unwrap_or(0) as usize;
match value {
Value::String(s) if s.len() < min => Err(Error::validation(format!(
"Must be at least {} characters",
min
))),
Value::Array(a) if a.len() < min => Err(Error::validation(format!(
"Must have at least {} items",
min
))),
_ => Ok(()),
}
},
);
self.register_fn(
"max_length",
"Maximum length validation",
|value, options| {
let max = options
.and_then(|o| o.get("max"))
.and_then(|v| v.as_u64())
.unwrap_or(u64::MAX) as usize;
match value {
Value::String(s) if s.len() > max => Err(Error::validation(format!(
"Must be at most {} characters",
max
))),
Value::Array(a) if a.len() > max => Err(Error::validation(format!(
"Must have at most {} items",
max
))),
_ => Ok(()),
}
},
);
self.register_fn("range", "Numeric range validation", |value, options| {
let min = options
.and_then(|o| o.get("min"))
.and_then(|v| v.as_f64())
.unwrap_or(f64::MIN);
let max = options
.and_then(|o| o.get("max"))
.and_then(|v| v.as_f64())
.unwrap_or(f64::MAX);
if let Some(num) = value.as_f64() {
if num < min || num > max {
return Err(Error::validation(format!(
"Must be between {} and {}",
min, max
)));
}
}
Ok(())
});
self.register_fn(
"pattern",
"Regular expression validation",
|value, options| {
let pattern = options
.and_then(|o| o.get("pattern"))
.and_then(|v| v.as_str())
.unwrap_or(".*");
if let Ok(regex) = Regex::new(pattern) {
if let Some(text) = value.as_str() {
if !regex.is_match(text) {
return Err(Error::validation("Value does not match required pattern"));
}
}
}
Ok(())
},
);
self.register_fn("alpha", "Alphabetic characters only", |value, _| {
if let Some(text) = value.as_str() {
if !text.chars().all(|c| c.is_alphabetic()) {
return Err(Error::validation("Must contain only alphabetic characters"));
}
}
Ok(())
});
self.register_fn(
"alphanumeric",
"Alphanumeric characters only",
|value, _| {
if let Some(text) = value.as_str() {
if !text.chars().all(|c| c.is_alphanumeric()) {
return Err(Error::validation(
"Must contain only alphanumeric characters",
));
}
}
Ok(())
},
);
self.register_fn(
"numeric",
"Numeric value validation",
|value, _| match value {
Value::Number(_) => Ok(()),
Value::String(s) => {
if s.parse::<f64>().is_ok() {
Ok(())
} else {
Err(Error::validation("Must be a numeric value"))
}
}
_ => Err(Error::validation("Must be a numeric value")),
},
);
self.register_fn(
"boolean",
"Boolean value validation",
|value, _| match value {
Value::Bool(_) => Ok(()),
Value::String(s) => {
let lower = s.to_lowercase();
if lower == "true" || lower == "false" || lower == "1" || lower == "0" {
Ok(())
} else {
Err(Error::validation("Must be a boolean value"))
}
}
Value::Number(n) => {
if let Some(i) = n.as_i64() {
if i == 0 || i == 1 {
return Ok(());
}
}
Err(Error::validation("Must be a boolean value"))
}
_ => Err(Error::validation("Must be a boolean value")),
},
);
self.register_fn("uuid", "UUID format validation", |value, _| {
if let Some(text) = value.as_str() {
let uuid_regex =
Regex::new(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
.unwrap();
if !uuid_regex.is_match(&text.to_lowercase()) {
return Err(Error::validation("Must be a valid UUID"));
}
}
Ok(())
});
}
}
impl Default for ValidatorRegistry {
fn default() -> Self {
Self::new()
}
}
pub struct EmailValidator;
impl Validator for EmailValidator {
fn validate(&self, value: &Value, _options: Option<&Value>) -> ValidationResult {
if let Some(email) = value.as_str() {
let email_regex = Regex::new(
r"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
).unwrap();
if !email_regex.is_match(email) {
return Err(Error::validation("Invalid email address"));
}
}
Ok(())
}
fn name(&self) -> &str {
"email"
}
fn description(&self) -> &str {
"Validates email address format"
}
}
pub struct UrlValidator;
impl Validator for UrlValidator {
fn validate(&self, value: &Value, _options: Option<&Value>) -> ValidationResult {
if let Some(url) = value.as_str() {
if url::Url::parse(url).is_err() {
return Err(Error::validation("Invalid URL format"));
}
}
Ok(())
}
fn name(&self) -> &str {
"url"
}
fn description(&self) -> &str {
"Validates URL format"
}
}
pub struct PhoneValidator;
impl Validator for PhoneValidator {
fn validate(&self, value: &Value, _options: Option<&Value>) -> ValidationResult {
if let Some(phone) = value.as_str() {
let cleaned: String = phone
.chars()
.filter(|c| c.is_numeric() || *c == '+')
.collect();
if cleaned.len() < 7 {
return Err(Error::validation("Phone number too short"));
}
if cleaned.len() > 15 {
return Err(Error::validation("Phone number too long"));
}
if cleaned.starts_with('+') && cleaned.len() < 8 {
return Err(Error::validation("Invalid international phone number"));
}
}
Ok(())
}
fn name(&self) -> &str {
"phone"
}
fn description(&self) -> &str {
"Validates phone number format"
}
}
pub struct CreditCardValidator;
impl CreditCardValidator {
fn luhn_check(number: &str) -> bool {
let digits: Vec<u32> = number
.chars()
.filter(|c| c.is_numeric())
.filter_map(|c| c.to_digit(10))
.collect();
if digits.len() < 13 || digits.len() > 19 {
return false;
}
let mut sum = 0;
let mut alternate = false;
for digit in digits.iter().rev() {
let mut n = *digit;
if alternate {
n *= 2;
if n > 9 {
n -= 9;
}
}
sum += n;
alternate = !alternate;
}
sum % 10 == 0
}
}
impl Validator for CreditCardValidator {
fn validate(&self, value: &Value, _options: Option<&Value>) -> ValidationResult {
if let Some(card_number) = value.as_str() {
if !Self::luhn_check(card_number) {
return Err(Error::validation("Invalid credit card number"));
}
}
Ok(())
}
fn name(&self) -> &str {
"credit_card"
}
fn description(&self) -> &str {
"Validates credit card number using Luhn algorithm"
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn test_required_validator() {
let registry = ValidatorRegistry::new();
assert!(registry.validate("required", &json!(null), None).is_err());
assert!(registry.validate("required", &json!(""), None).is_err());
assert!(registry.validate("required", &json!([]), None).is_err());
assert!(registry.validate("required", &json!("value"), None).is_ok());
assert!(registry.validate("required", &json!(123), None).is_ok());
}
#[test]
fn test_email_validator() {
let registry = ValidatorRegistry::new();
assert!(registry
.validate("email", &json!("test@example.com"), None)
.is_ok());
assert!(registry
.validate("email", &json!("user.name+tag@example.co.uk"), None)
.is_ok());
assert!(registry
.validate("email", &json!("invalid.email"), None)
.is_err());
assert!(registry
.validate("email", &json!("@example.com"), None)
.is_err());
assert!(registry.validate("email", &json!("test@"), None).is_err());
}
#[test]
fn test_url_validator() {
let registry = ValidatorRegistry::new();
assert!(registry
.validate("url", &json!("https://example.com"), None)
.is_ok());
assert!(registry
.validate("url", &json!("http://localhost:8080"), None)
.is_ok());
assert!(registry
.validate("url", &json!("ftp://files.example.com"), None)
.is_ok());
assert!(registry.validate("url", &json!("not-a-url"), None).is_err());
assert!(registry
.validate("url", &json!("//example.com"), None)
.is_err());
}
#[test]
fn test_phone_validator() {
let registry = ValidatorRegistry::new();
assert!(registry.validate("phone", &json!("1234567"), None).is_ok());
assert!(registry
.validate("phone", &json!("+1234567890"), None)
.is_ok());
assert!(registry
.validate("phone", &json!("(555) 123-4567"), None)
.is_ok());
assert!(registry.validate("phone", &json!("123"), None).is_err());
assert!(registry
.validate("phone", &json!("1234567890123456"), None)
.is_err());
}
#[test]
fn test_credit_card_validator() {
let registry = ValidatorRegistry::new();
assert!(registry
.validate("credit_card", &json!("4532015112830366"), None)
.is_ok()); assert!(registry
.validate("credit_card", &json!("5425233430109903"), None)
.is_ok()); assert!(registry
.validate("credit_card", &json!("374245455400126"), None)
.is_ok());
assert!(registry
.validate("credit_card", &json!("1234567890123456"), None)
.is_err());
assert!(registry
.validate("credit_card", &json!("0000000000000000"), None)
.is_ok());
}
#[test]
fn test_range_validator() {
let registry = ValidatorRegistry::new();
let options = json!({"min": 0, "max": 100});
assert!(registry
.validate("range", &json!(50), Some(&options))
.is_ok());
assert!(registry
.validate("range", &json!(0), Some(&options))
.is_ok());
assert!(registry
.validate("range", &json!(100), Some(&options))
.is_ok());
assert!(registry
.validate("range", &json!(-1), Some(&options))
.is_err());
assert!(registry
.validate("range", &json!(101), Some(&options))
.is_err());
}
}