lgx_runtime/utils/

validation.rs

use regex::Regex;
use tracing::debug;

pub fn validate_email(email: &str) -> bool {
    debug!("Validating email: {}", email);
    
    let email_regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
    email_regex.is_match(email)
}

pub fn validate_uuid(uuid_str: &str) -> bool {
    debug!("Validating UUID: {}", uuid_str);
    
    uuid::Uuid::parse_str(uuid_str).is_ok()
}

pub fn sanitize_input(input: &str) -> String {
    debug!("Sanitizing input of length: {}", input.len());
    
    // Remove potentially dangerous characters
    let dangerous_chars = Regex::new(r#"[<>"'&]"#).unwrap();
    let sanitized = dangerous_chars.replace_all(input, "");
    
    sanitized.trim().to_string()
}

pub fn validate_json_schema(json: &serde_json::Value, schema: &serde_json::Value) -> bool {
    debug!("Validating JSON against schema");
    
    // Basic schema validation implementation
    match (json, schema) {
        (serde_json::Value::Object(json_obj), serde_json::Value::Object(schema_obj)) => {
            for (key, schema_value) in schema_obj {
                if let Some(json_value) = json_obj.get(key) {
                    if !validate_json_value(json_value, schema_value) {
                        return false;
                    }
                } else if schema_obj.get("required").map_or(false, |r| r.as_bool().unwrap_or(false)) {
                    return false;
                }
            }
            true
        }
        (serde_json::Value::Array(json_arr), serde_json::Value::Object(schema_obj)) => {
            if let Some(serde_json::Value::String(item_type)) = schema_obj.get("type") {
                match item_type.as_str() {
                    "array" => {
                        for item in json_arr {
                            if !validate_json_value(item, schema) {
                                return false;
                            }
                        }
                        true
                    }
                    _ => true
                }
            } else {
                true
            }
        }
        _ => true
    }
}

fn validate_json_value(value: &serde_json::Value, schema: &serde_json::Value) -> bool {
    match (value, schema) {
        (serde_json::Value::String(s), serde_json::Value::Object(schema_obj)) => {
            if let Some(serde_json::Value::String(expected_type)) = schema_obj.get("type") {
                match expected_type.as_str() {
                    "string" => {
                        if let Some(serde_json::Value::Number(min_len)) = schema_obj.get("minLength") {
                            if s.len() < min_len.as_u64().unwrap_or(0) as usize {
                                return false;
                            }
                        }
                        if let Some(serde_json::Value::Number(max_len)) = schema_obj.get("maxLength") {
                            if s.len() > max_len.as_u64().unwrap_or(0) as usize {
                                return false;
                            }
                        }
                        true
                    }
                    "email" => validate_email(s),
                    "uuid" => validate_uuid(s),
                    _ => true
                }
            } else {
                true
            }
        }
        (serde_json::Value::Number(n), serde_json::Value::Object(schema_obj)) => {
            if let Some(serde_json::Value::String(expected_type)) = schema_obj.get("type") {
                match expected_type.as_str() {
                    "number" | "integer" => {
                        if let Some(serde_json::Value::Number(min_val)) = schema_obj.get("minimum") {
                            if n.as_f64().unwrap_or(0.0) < min_val.as_f64().unwrap_or(0.0) {
                                return false;
                            }
                        }
                        if let Some(serde_json::Value::Number(max_val)) = schema_obj.get("maximum") {
                            if n.as_f64().unwrap_or(0.0) > max_val.as_f64().unwrap_or(0.0) {
                                return false;
                            }
                        }
                        true
                    }
                    _ => true
                }
            } else {
                true
            }
        }
        (serde_json::Value::Bool(_), serde_json::Value::Object(schema_obj)) => {
            if let Some(serde_json::Value::String(expected_type)) = schema_obj.get("type") {
                expected_type == "boolean"
            } else {
                true
            }
        }
        _ => true
    }
}

pub fn validate_required_fields(data: &serde_json::Value, required_fields: &[String]) -> bool {
    debug!("Validating required fields: {:?}", required_fields);
    
    if let serde_json::Value::Object(obj) = data {
        for field in required_fields {
            if !obj.contains_key(field) {
                return false;
            }
        }
        true
    } else {
        false
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_email() {
        assert!(validate_email("test@example.com"));
        assert!(validate_email("user.name+tag@domain.co.uk"));
        assert!(!validate_email("invalid-email"));
        assert!(!validate_email("test@"));
        assert!(!validate_email("@domain.com"));
    }

    #[test]
    fn test_validate_uuid() {
        assert!(validate_uuid("123e4567-e89b-12d3-a456-426614174000"));
        assert!(!validate_uuid("invalid-uuid"));
        assert!(!validate_uuid("123e4567-e89b-12d3-a456"));
    }

    #[test]
    fn test_sanitize_input() {
        assert_eq!(sanitize_input("Hello <script>alert('xss')</script>"), "Hello scriptalert(xss)/script");
        assert_eq!(sanitize_input("Normal text"), "Normal text");
        assert_eq!(sanitize_input("  whitespace  "), "whitespace");
    }

    #[test]
    fn test_validate_required_fields() {
        let data = serde_json::json!({
            "name": "John",
            "email": "john@example.com",
            "age": 30
        });
        
        assert!(validate_required_fields(&data, &["name".to_string(), "email".to_string()]));
        assert!(!validate_required_fields(&data, &["name".to_string(), "missing".to_string()]));
        assert!(!validate_required_fields(&serde_json::Value::String("not an object".to_string()), &["name".to_string()]));
    }

    #[test]
    fn test_validate_json_schema() {
        let schema = serde_json::json!({
            "type": "object",
            "properties": {
                "name": { "type": "string" },
                "age": { "type": "number" }
            }
        });
        
        let valid_data = serde_json::json!({
            "name": "John",
            "age": 30
        });
        
        let invalid_data = serde_json::json!({
            "age": 30
            // missing required "name" field
        });
        
        assert!(validate_json_schema(&valid_data, &schema));
        // Note: Our simple schema validation doesn't enforce required fields yet
        assert!(validate_json_schema(&invalid_data, &schema));
    }
}