Method validate_json_against_schema

core/src/validation.rs:200–363

(
        &self,
        data: &serde_json::Value,
        schema: &serde_json::Value,
        path: &str,
    )

    /// Validate JSON value against schema
    #[allow(clippy::only_used_in_recursion)]
    fn validate_json_against_schema(
        &self,
        data: &serde_json::Value,
        schema: &serde_json::Value,
        path: &str,
    ) -> ValidationResult {
        let mut result = ValidationResult::success();

        // Extract schema properties
        let schema_obj = match schema.as_object() {
            Some(obj) => obj,
            None => {
                result.add_error(ValidationError::new(
                    path,
                    "Schema must be an object",
                    "INVALID_SCHEMA",
                ));
                return result;
            }
        };

        // Check type
        if let Some(expected_type) = schema_obj.get("type").and_then(|t| t.as_str()) {
            let actual_type = match data {
                serde_json::Value::Null => "null",
                serde_json::Value::Bool(_) => "boolean",
                serde_json::Value::Number(_) => "number",
                serde_json::Value::String(_) => "string",
                serde_json::Value::Array(_) => "array",
                serde_json::Value::Object(_) => "object",
            };

            if expected_type != actual_type {
                result.add_error(
                    ValidationError::new(path, "Type mismatch".to_string(), "TYPE_MISMATCH")
                        .with_expected(expected_type)
                        .with_actual(actual_type),
                );
                return result;
            }
        }

        // Validate object properties
        if let (Some(data_obj), Some(properties)) = (
            data.as_object(),
            schema_obj.get("properties").and_then(|p| p.as_object()),
        ) {
            // Check required properties
            if let Some(required) = schema_obj.get("required").and_then(|r| r.as_array()) {
                for req_prop in required {
                    if let Some(prop_name) = req_prop.as_str() {
                        if !data_obj.contains_key(prop_name) {
                            result.add_error(ValidationError::new(
                                format!("{path}.{prop_name}"),
                                format!("Required property '{prop_name}' is missing"),
                                "MISSING_REQUIRED_PROPERTY",
                            ));
                        }