diff --git a/src/lib.rs b/src/lib.rs index 9a47e1d..1eeb1fb 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,9 +2,10 @@ use pgrx::*; pg_module_magic!(); -use boon::{CompileError, Compiler, ErrorKind, SchemaIndex, Schemas, ValidationError}; +use boon::{CompileError, Compiler, ErrorKind, SchemaIndex, Schemas, ValidationError, Type, Types}; use lazy_static::lazy_static; -use serde_json::{json, Value}; +use serde_json::{json, Value, Number}; +use std::borrow::Cow; use std::collections::hash_map::Entry; use std::{collections::HashMap, sync::RwLock}; @@ -19,7 +20,7 @@ struct Error { path: String, code: String, message: String, - cause: String, + cause: Value, // Changed from String to Value to store JSON } lazy_static! { @@ -185,101 +186,53 @@ fn collect_errors(error: &ValidationError, errors_list: &mut Vec) { } if error.causes.is_empty() && !is_structural { - // Handle errors with multiple fields specially - match &error.kind { - ErrorKind::Required { want } => { - // Create a separate error for each missing required field - let base_path = error.instance_location.to_string(); - for missing_field in want { - let field_path = if base_path.is_empty() { - format!("/{}", missing_field) - } else { - format!("{}/{}", base_path, missing_field) - }; - - errors_list.push(Error { - path: field_path, - code: "REQUIRED_FIELD_MISSING".to_string(), - message: format!("Required field '{}' is missing", missing_field), - cause: format!("property '{}' is required", missing_field), - }); - } - } - ErrorKind::Dependency { prop, missing } | ErrorKind::DependentRequired { prop, missing } => { - // Create a separate error for each missing field - let base_path = error.instance_location.to_string(); - for missing_field in missing { - let field_path = if base_path.is_empty() { - format!("/{}", missing_field) - } else { - format!("{}/{}", base_path, missing_field) - }; - - let (error_code, human_message) = match &error.kind { - ErrorKind::Dependency { .. } => ( - "DEPENDENCY_FAILED".to_string(), - format!("Field '{}' is required when '{}' is present", missing_field, prop), - ), - ErrorKind::DependentRequired { .. } => ( - "DEPENDENT_REQUIRED_MISSING".to_string(), - format!("Field '{}' is required when '{}' is present", missing_field, prop), - ), - _ => unreachable!(), - }; - - errors_list.push(Error { - path: field_path, - code: error_code, - message: human_message, - cause: format!("property '{}' required, if '{}' property exists", missing_field, prop), - }); - } - } - ErrorKind::AdditionalProperties { got } => { - // Create a separate error for each additional property that's not allowed - let base_path = error.instance_location.to_string(); - for extra_prop in got { - let field_path = if base_path.is_empty() { - format!("/{}", extra_prop) - } else { - format!("{}/{}", base_path, extra_prop) - }; - - errors_list.push(Error { - path: field_path, - code: "ADDITIONAL_PROPERTIES_NOT_ALLOWED".to_string(), - message: format!("Property '{}' is not allowed", extra_prop), - cause: format!("additionalProperty '{}' not allowed", extra_prop), - }); - } - } - ErrorKind::Pattern { got, want } => { - // Special handling for pattern errors to include the pattern in the message - let display_value = if got.len() > 50 { - format!("{}...", &got[..50]) - } else { - got.to_string() - }; - - errors_list.push(Error { - path: error.instance_location.to_string(), - code: "PATTERN_VIOLATED".to_string(), - message: format!("Value does not match pattern: {}", want), - cause: format!("'{}' does not match pattern {}", display_value, want), - }); - } - _ => { - // Handle all other error types normally - let original_message = format!("{}", error.kind); - let (error_code, human_message) = convert_error_kind(&error.kind); - - errors_list.push(Error { - path: error.instance_location.to_string(), - code: error_code, - message: human_message, - cause: original_message, - }); - } + let base_path = error.instance_location.to_string(); + + // Match on error kind and handle each type + let errors_to_add = match &error.kind { + ErrorKind::Type { got, want } => handle_type_error(&base_path, got, want), + ErrorKind::Required { want } => handle_required_error(&base_path, want), + ErrorKind::Dependency { prop, missing } => handle_dependency_error(&base_path, prop, missing, false), + ErrorKind::DependentRequired { prop, missing } => handle_dependency_error(&base_path, prop, missing, true), + ErrorKind::AdditionalProperties { got } => handle_additional_properties_error(&base_path, got), + ErrorKind::Enum { want } => handle_enum_error(&base_path, want), + ErrorKind::Const { want } => handle_const_error(&base_path, want), + ErrorKind::MinLength { got, want } => handle_min_length_error(&base_path, *got, *want), + ErrorKind::MaxLength { got, want } => handle_max_length_error(&base_path, *got, *want), + ErrorKind::Pattern { got, want } => handle_pattern_error(&base_path, got, want), + ErrorKind::Minimum { got, want } => handle_minimum_error(&base_path, got, want), + ErrorKind::Maximum { got, want } => handle_maximum_error(&base_path, got, want), + ErrorKind::ExclusiveMinimum { got, want } => handle_exclusive_minimum_error(&base_path, got, want), + ErrorKind::ExclusiveMaximum { got, want } => handle_exclusive_maximum_error(&base_path, got, want), + ErrorKind::MultipleOf { got, want } => handle_multiple_of_error(&base_path, got, want), + ErrorKind::MinItems { got, want } => handle_min_items_error(&base_path, *got, *want), + ErrorKind::MaxItems { got, want } => handle_max_items_error(&base_path, *got, *want), + ErrorKind::UniqueItems { got } => handle_unique_items_error(&base_path, got), + ErrorKind::MinProperties { got, want } => handle_min_properties_error(&base_path, *got, *want), + ErrorKind::MaxProperties { got, want } => handle_max_properties_error(&base_path, *got, *want), + ErrorKind::AdditionalItems { got } => handle_additional_items_error(&base_path, *got), + ErrorKind::Format { want, got, err } => handle_format_error(&base_path, want, got, err), + ErrorKind::PropertyName { prop } => handle_property_name_error(&base_path, prop), + ErrorKind::Contains => handle_contains_error(&base_path), + ErrorKind::MinContains { got, want } => handle_min_contains_error(&base_path, got, *want), + ErrorKind::MaxContains { got, want } => handle_max_contains_error(&base_path, got, *want), + ErrorKind::ContentEncoding { want, err } => handle_content_encoding_error(&base_path, want, err), + ErrorKind::ContentMediaType { want, err, .. } => handle_content_media_type_error(&base_path, want, err), + ErrorKind::FalseSchema => handle_false_schema_error(&base_path), + ErrorKind::Not => handle_not_error(&base_path), + ErrorKind::RefCycle { url, kw_loc1, kw_loc2 } => handle_ref_cycle_error(&base_path, url, kw_loc1, kw_loc2), + ErrorKind::Reference { kw, url } => handle_reference_error(&base_path, kw, url), + ErrorKind::Schema { url } => handle_schema_error(&base_path, url), + ErrorKind::ContentSchema => handle_content_schema_error(&base_path), + ErrorKind::Group => handle_group_error(&base_path), + ErrorKind::AllOf => handle_all_of_error(&base_path), + ErrorKind::AnyOf => handle_any_of_error(&base_path), + ErrorKind::OneOf(matched) => handle_one_of_error(&base_path, matched), + }; + + // Add all generated errors + for error in errors_to_add { + errors_list.push(error); } } else { // Recurse into causes @@ -289,163 +242,428 @@ fn collect_errors(error: &ValidationError, errors_list: &mut Vec) { } } -// Convert ErrorKind to error code and human message -fn convert_error_kind(kind: &ErrorKind) -> (String, String) { - match kind { - ErrorKind::Type { .. } => ( - "TYPE_MISMATCH".to_string(), - "Field type does not match the expected type".to_string(), +// Handler functions for each error kind +fn handle_type_error(base_path: &str, got: &Type, want: &Types) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "TYPE_MISMATCH".to_string(), + message: format!("Expected {} but got {}", + want.iter().map(|t| t.to_string()).collect::>().join(" or "), + got ), - ErrorKind::Required { .. } => ( - "REQUIRED_FIELD_MISSING".to_string(), - "Required field is missing".to_string(), + cause: json!({ + "got": got.to_string(), + "want": want.iter().map(|t| t.to_string()).collect::>() + }), + }] +} + +fn handle_required_error(base_path: &str, want: &[&str]) -> Vec { + // Create a separate error for each missing required field + want.iter().map(|missing_field| { + let field_path = if base_path.is_empty() { + format!("/{}", missing_field) + } else { + format!("{}/{}", base_path, missing_field) + }; + + Error { + path: field_path, + code: "REQUIRED_FIELD_MISSING".to_string(), + message: format!("Required field '{}' is missing", missing_field), + cause: json!({ "want": [missing_field] }), + } + }).collect() +} + +fn handle_dependency_error(base_path: &str, prop: &str, missing: &[&str], is_dependent_required: bool) -> Vec { + // Create a separate error for each missing field + missing.iter().map(|missing_field| { + let field_path = if base_path.is_empty() { + format!("/{}", missing_field) + } else { + format!("{}/{}", base_path, missing_field) + }; + + let (code, message) = if is_dependent_required { + ( + "DEPENDENT_REQUIRED_MISSING".to_string(), + format!("Field '{}' is required when '{}' is present", missing_field, prop), + ) + } else { + ( + "DEPENDENCY_FAILED".to_string(), + format!("Field '{}' is required when '{}' is present", missing_field, prop), + ) + }; + + Error { + path: field_path, + code, + message, + cause: json!({ "prop": prop, "missing": [missing_field] }), + } + }).collect() +} + +fn handle_additional_properties_error(base_path: &str, got: &[Cow]) -> Vec { + // Create a separate error for each additional property that's not allowed + got.iter().map(|extra_prop| { + let field_path = if base_path.is_empty() { + format!("/{}", extra_prop) + } else { + format!("{}/{}", base_path, extra_prop) + }; + + Error { + path: field_path, + code: "ADDITIONAL_PROPERTIES_NOT_ALLOWED".to_string(), + message: format!("Property '{}' is not allowed", extra_prop), + cause: json!({ "got": [extra_prop.to_string()] }), + } + }).collect() +} + +fn handle_enum_error(base_path: &str, want: &[Value]) -> Vec { + let message = if want.len() == 1 { + format!("Value must be {}", serde_json::to_string(&want[0]).unwrap_or_else(|_| "unknown".to_string())) + } else { + format!("Value must be one of: {}", + want.iter() + .map(|v| serde_json::to_string(v).unwrap_or_else(|_| "unknown".to_string())) + .collect::>() + .join(", ") + ) + }; + + vec![Error { + path: base_path.to_string(), + code: "ENUM_VIOLATED".to_string(), + message, + cause: json!({ "want": want }), + }] +} + +fn handle_const_error(base_path: &str, want: &Value) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "CONST_VIOLATED".to_string(), + message: format!("Value must be exactly {}", serde_json::to_string(want).unwrap_or_else(|_| "unknown".to_string())), + cause: json!({ "want": want }), + }] +} + +fn handle_min_length_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MIN_LENGTH_VIOLATED".to_string(), + message: format!("String length must be at least {} characters, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_max_length_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MAX_LENGTH_VIOLATED".to_string(), + message: format!("String length must be at most {} characters, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_pattern_error(base_path: &str, got: &Cow, want: &str) -> Vec { + let display_value = if got.len() > 50 { + format!("{}...", &got[..50]) + } else { + got.to_string() + }; + + vec![Error { + path: base_path.to_string(), + code: "PATTERN_VIOLATED".to_string(), + message: format!("Value '{}' does not match pattern '{}'", display_value, want), + cause: json!({ "got": got.to_string(), "want": want }), + }] +} + +fn handle_minimum_error(base_path: &str, got: &Cow, want: &Number) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MINIMUM_VIOLATED".to_string(), + message: format!("Value must be at least {}, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_maximum_error(base_path: &str, got: &Cow, want: &Number) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MAXIMUM_VIOLATED".to_string(), + message: format!("Value must be at most {}, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_exclusive_minimum_error(base_path: &str, got: &Cow, want: &Number) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "EXCLUSIVE_MINIMUM_VIOLATED".to_string(), + message: format!("Value must be greater than {}, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_exclusive_maximum_error(base_path: &str, got: &Cow, want: &Number) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "EXCLUSIVE_MAXIMUM_VIOLATED".to_string(), + message: format!("Value must be less than {}, but got {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_multiple_of_error(base_path: &str, got: &Cow, want: &Number) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MULTIPLE_OF_VIOLATED".to_string(), + message: format!("{} is not a multiple of {}", got, want), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_min_items_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MIN_ITEMS_VIOLATED".to_string(), + message: format!("Array must have at least {} items, but has {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_max_items_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MAX_ITEMS_VIOLATED".to_string(), + message: format!("Array must have at most {} items, but has {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_unique_items_error(base_path: &str, got: &[usize; 2]) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "UNIQUE_ITEMS_VIOLATED".to_string(), + message: format!("Array items at positions {} and {} are duplicates", got[0], got[1]), + cause: json!({ "got": got }), + }] +} + +fn handle_min_properties_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MIN_PROPERTIES_VIOLATED".to_string(), + message: format!("Object must have at least {} properties, but has {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_max_properties_error(base_path: &str, got: usize, want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MAX_PROPERTIES_VIOLATED".to_string(), + message: format!("Object must have at most {} properties, but has {}", want, got), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_additional_items_error(base_path: &str, got: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "ADDITIONAL_ITEMS_NOT_ALLOWED".to_string(), + message: format!("Last {} array items are not allowed", got), + cause: json!({ "got": got }), + }] +} + +fn handle_format_error(base_path: &str, want: &str, got: &Cow, err: &Box) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "FORMAT_INVALID".to_string(), + message: format!("Value {} is not a valid {} format", + serde_json::to_string(got.as_ref()).unwrap_or_else(|_| "unknown".to_string()), + want ), - ErrorKind::DependentRequired { .. } => ( - "DEPENDENT_REQUIRED_MISSING".to_string(), - "Dependent required fields are missing".to_string(), + cause: json!({ "got": got, "want": want, "err": err.to_string() }), + }] +} + +fn handle_property_name_error(base_path: &str, prop: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "INVALID_PROPERTY_NAME".to_string(), + message: format!("Property name '{}' is invalid", prop), + cause: json!({ "prop": prop }), + }] +} + +fn handle_contains_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "CONTAINS_FAILED".to_string(), + message: "No array items match the required schema".to_string(), + cause: json!({}), + }] +} + +fn handle_min_contains_error(base_path: &str, got: &[usize], want: usize) -> Vec { + let message = if got.is_empty() { + format!("At least {} array items must match the schema, but none do", want) + } else { + format!("At least {} array items must match the schema, but only {} do (at positions {})", + want, + got.len(), + got.iter().map(|i| i.to_string()).collect::>().join(", ") + ) + }; + + vec![Error { + path: base_path.to_string(), + code: "MIN_CONTAINS_VIOLATED".to_string(), + message, + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_max_contains_error(base_path: &str, got: &[usize], want: usize) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "MAX_CONTAINS_VIOLATED".to_string(), + message: format!("At most {} array items can match the schema, but {} do (at positions {})", + want, + got.len(), + got.iter().map(|i| i.to_string()).collect::>().join(", ") ), - ErrorKind::Dependency { .. } => ( - "DEPENDENCY_FAILED".to_string(), - "Dependency requirement not met".to_string(), + cause: json!({ "got": got, "want": want }), + }] +} + +fn handle_content_encoding_error(base_path: &str, want: &str, err: &Box) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "CONTENT_ENCODING_INVALID".to_string(), + message: format!("Content is not valid {} encoding: {}", want, err), + cause: json!({ "want": want, "err": err.to_string() }), + }] +} + +fn handle_content_media_type_error(base_path: &str, want: &str, err: &Box) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "CONTENT_MEDIA_TYPE_INVALID".to_string(), + message: format!("Content is not valid {} media type: {}", want, err), + cause: json!({ "want": want, "err": err.to_string() }), + }] +} + +fn handle_false_schema_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "FALSE_SCHEMA".to_string(), + message: "This schema always fails validation".to_string(), + cause: json!({}), + }] +} + +fn handle_not_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "NOT_VIOLATED".to_string(), + message: "Value matches a schema that it should not match".to_string(), + cause: json!({}), + }] +} + +fn handle_ref_cycle_error(base_path: &str, url: &str, kw_loc1: &str, kw_loc2: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "REFERENCE_CYCLE".to_string(), + message: format!("Reference cycle detected: both '{}' and '{}' resolve to '{}'", kw_loc1, kw_loc2, url), + cause: json!({ "url": url, "kw_loc1": kw_loc1, "kw_loc2": kw_loc2 }), + }] +} + +fn handle_reference_error(base_path: &str, kw: &str, url: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "REFERENCE_FAILED".to_string(), + message: format!("{} reference to '{}' failed validation", kw, url), + cause: json!({ "kw": kw, "url": url }), + }] +} + +fn handle_schema_error(base_path: &str, url: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "SCHEMA_FAILED".to_string(), + message: format!("Schema '{}' validation failed", url), + cause: json!({ "url": url }), + }] +} + +fn handle_content_schema_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "CONTENT_SCHEMA_FAILED".to_string(), + message: "Content schema validation failed".to_string(), + cause: json!({}), + }] +} + +fn handle_group_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "VALIDATION_FAILED".to_string(), + message: "Validation failed".to_string(), + cause: json!({}), + }] +} + +fn handle_all_of_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "ALL_OF_VIOLATED".to_string(), + message: "Value does not match all required schemas".to_string(), + cause: json!({}), + }] +} + +fn handle_any_of_error(base_path: &str) -> Vec { + vec![Error { + path: base_path.to_string(), + code: "ANY_OF_VIOLATED".to_string(), + message: "Value does not match any of the allowed schemas".to_string(), + cause: json!({}), + }] +} + +fn handle_one_of_error(base_path: &str, matched: &Option<(usize, usize)>) -> Vec { + let (message, cause) = match matched { + None => ( + "Value must match exactly one schema, but matches none".to_string(), + json!({ "matched_indices": null }) ), - ErrorKind::Enum { .. } => ( - "ENUM_VIOLATED".to_string(), - "Value is not one of the allowed options".to_string(), + Some((i, j)) => ( + format!("Value must match exactly one schema, but matches schemas at positions {} and {}", i, j), + json!({ "matched_indices": [i, j] }) ), - ErrorKind::Const { .. } => ( - "CONST_VIOLATED".to_string(), - "Value does not match the required constant".to_string(), - ), - ErrorKind::MinLength { .. } => ( - "MIN_LENGTH_VIOLATED".to_string(), - "Field length is below the minimum required".to_string(), - ), - ErrorKind::MaxLength { .. } => ( - "MAX_LENGTH_VIOLATED".to_string(), - "Field length exceeds the maximum allowed".to_string(), - ), - ErrorKind::Pattern { .. } => ( - "PATTERN_VIOLATED".to_string(), - "Value does not match the required pattern".to_string(), - ), - ErrorKind::Minimum { .. } => ( - "MINIMUM_VIOLATED".to_string(), - "Value is below the minimum allowed".to_string(), - ), - ErrorKind::Maximum { .. } => ( - "MAXIMUM_VIOLATED".to_string(), - "Value exceeds the maximum allowed".to_string(), - ), - ErrorKind::ExclusiveMinimum { .. } => ( - "EXCLUSIVE_MINIMUM_VIOLATED".to_string(), - "Value must be greater than the minimum".to_string(), - ), - ErrorKind::ExclusiveMaximum { .. } => ( - "EXCLUSIVE_MAXIMUM_VIOLATED".to_string(), - "Value must be less than the maximum".to_string(), - ), - ErrorKind::MultipleOf { .. } => ( - "MULTIPLE_OF_VIOLATED".to_string(), - "Value is not a multiple of the required factor".to_string(), - ), - ErrorKind::MinItems { .. } => ( - "MIN_ITEMS_VIOLATED".to_string(), - "Array has fewer items than required".to_string(), - ), - ErrorKind::MaxItems { .. } => ( - "MAX_ITEMS_VIOLATED".to_string(), - "Array has more items than allowed".to_string(), - ), - ErrorKind::UniqueItems { .. } => ( - "UNIQUE_ITEMS_VIOLATED".to_string(), - "Array contains duplicate items".to_string(), - ), - ErrorKind::MinProperties { .. } => ( - "MIN_PROPERTIES_VIOLATED".to_string(), - "Object has fewer properties than required".to_string(), - ), - ErrorKind::MaxProperties { .. } => ( - "MAX_PROPERTIES_VIOLATED".to_string(), - "Object has more properties than allowed".to_string(), - ), - ErrorKind::AdditionalProperties { .. } => ( - "ADDITIONAL_PROPERTIES_NOT_ALLOWED".to_string(), - "Object contains properties that are not allowed".to_string(), - ), - ErrorKind::AdditionalItems { .. } => ( - "ADDITIONAL_ITEMS_NOT_ALLOWED".to_string(), - "Array contains additional items that are not allowed".to_string(), - ), - ErrorKind::Format { want, .. } => ( - "FORMAT_INVALID".to_string(), - format!("Invalid {} format", want), - ), - ErrorKind::PropertyName { .. } => ( - "INVALID_PROPERTY_NAME".to_string(), - "Property name is invalid".to_string(), - ), - ErrorKind::Contains => ( - "CONTAINS_FAILED".to_string(), - "No items match the required schema".to_string(), - ), - ErrorKind::MinContains { .. } => ( - "MIN_CONTAINS_VIOLATED".to_string(), - "Too few items match the required schema".to_string(), - ), - ErrorKind::MaxContains { .. } => ( - "MAX_CONTAINS_VIOLATED".to_string(), - "Too many items match the required schema".to_string(), - ), - ErrorKind::ContentEncoding { .. } => ( - "CONTENT_ENCODING_INVALID".to_string(), - "Content encoding is invalid".to_string(), - ), - ErrorKind::ContentMediaType { .. } => ( - "CONTENT_MEDIA_TYPE_INVALID".to_string(), - "Content media type is invalid".to_string(), - ), - ErrorKind::FalseSchema => ( - "FALSE_SCHEMA".to_string(), - "Schema validation always fails".to_string(), - ), - ErrorKind::Not => ( - "NOT_VIOLATED".to_string(), - "Value matched a schema it should not match".to_string(), - ), - ErrorKind::RefCycle { .. } => ( - "REFERENCE_CYCLE".to_string(), - "Schema contains a reference cycle".to_string(), - ), - ErrorKind::Reference { .. } => ( - "REFERENCE_FAILED".to_string(), - "Reference validation failed".to_string(), - ), - ErrorKind::Schema { .. } => ( - "SCHEMA_FAILED".to_string(), - "Schema validation failed".to_string(), - ), - ErrorKind::ContentSchema => ( - "CONTENT_SCHEMA_FAILED".to_string(), - "Content schema validation failed".to_string(), - ), - // These shouldn't appear as leaf errors due to is_structural check - ErrorKind::Group => ( - "VALIDATION_FAILED".to_string(), - "Validation failed".to_string(), - ), - ErrorKind::AllOf => ( - "ALL_OF_VIOLATED".to_string(), - "Value does not match all required schemas".to_string(), - ), - ErrorKind::AnyOf => ( - "ANY_OF_VIOLATED".to_string(), - "Value does not match any of the allowed schemas".to_string(), - ), - ErrorKind::OneOf(_) => ( - "ONE_OF_VIOLATED".to_string(), - "Value must match exactly one schema".to_string(), - ), - } + }; + + vec![Error { + path: base_path.to_string(), + code: "ONE_OF_VIOLATED".to_string(), + message, + cause, + }] } // Filter out FALSE_SCHEMA errors if there are other validation errors diff --git a/src/tests.rs b/src/tests.rs index 8ca8c01..4231c93 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -151,12 +151,17 @@ fn test_cache_and_validate_json_schema() { // Invalid type - age is negative let invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type)); - assert_failure_with_json!(invalid_result_type, 1, "Value is below the minimum allowed", "Validation with invalid type should fail."); + assert_failure_with_json!(invalid_result_type, 1, "Value must be at least 0, but got -5", "Validation with invalid type should fail."); let errors_type = invalid_result_type.0["errors"].as_array().unwrap(); assert_eq!(errors_type[0]["details"]["path"], "/age"); assert_eq!(errors_type[0]["details"]["context"], -5); assert_eq!(errors_type[0]["details"]["schema"], "my_schema"); assert_eq!(errors_type[0]["code"], "MINIMUM_VIOLATED"); + // Check the cause is now a JSON object + let cause_type = &errors_type[0]["details"]["cause"]; + assert!(cause_type.is_object()); + assert_eq!(cause_type["got"], -5); + assert_eq!(cause_type["want"], 0); // Missing field let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing)); @@ -165,6 +170,10 @@ fn test_cache_and_validate_json_schema() { assert_eq!(errors_missing[0]["details"]["path"], "/age"); assert_eq!(errors_missing[0]["details"]["schema"], "my_schema"); assert_eq!(errors_missing[0]["code"], "REQUIRED_FIELD_MISSING"); + // Check the cause is now a JSON object + let cause_missing = &errors_missing[0]["details"]["cause"]; + assert!(cause_missing.is_object()); + assert_eq!(cause_missing["want"], json!(["age"])); // Schema not found let non_existent_id = "non_existent_schema"; @@ -173,6 +182,8 @@ fn test_cache_and_validate_json_schema() { let errors_notfound = invalid_schema_result.0["errors"].as_array().unwrap(); assert_eq!(errors_notfound[0]["code"], "SCHEMA_NOT_FOUND"); assert_eq!(errors_notfound[0]["details"]["schema"], "non_existent_schema"); + // Schema not found still has string cause (it's not from ErrorKind) + assert_eq!(errors_notfound[0]["details"]["cause"], "Schema must be cached before validation"); } #[pg_test] @@ -200,7 +211,7 @@ fn test_cache_invalid_json_schema() { assert_failure_with_json!( cache_result, 2, // Expect exactly two leaf errors - "Value is not one of the allowed options", // Updated to human-readable message + "Value must be one of", // Updated to human-readable message "Caching invalid schema should fail with specific meta-schema validation errors." ); @@ -219,6 +230,12 @@ fn test_cache_invalid_json_schema() { // Check schema field is present assert_eq!(errors_array[0]["details"]["schema"], "invalid_schema"); assert_eq!(errors_array[1]["details"]["schema"], "invalid_schema"); + // Check that cause is now a JSON object with want array + for error in errors_array { + let cause = &error["details"]["cause"]; + assert!(cause.is_object()); + assert!(cause["want"].is_array()); + } } #[pg_test] @@ -417,23 +434,32 @@ fn test_root_level_type_mismatch() { // Test 1: Validate null against array schema (simulating delete_tokens issue) let null_instance = json!(null); let null_result = validate_json_schema(schema_id, jsonb(null_instance)); - assert_failure_with_json!(null_result, 1, "Field type does not match the expected type"); + assert_failure_with_json!(null_result, 1, "Expected array but got null"); let null_errors = null_result.0["errors"].as_array().unwrap(); assert_eq!(null_errors[0]["code"], "TYPE_MISMATCH"); assert_eq!(null_errors[0]["details"]["path"], ""); // Root level path should be empty string assert_eq!(null_errors[0]["details"]["context"], json!(null)); assert_eq!(null_errors[0]["details"]["schema"], "array_schema"); - assert!(null_errors[0]["details"]["cause"].as_str().unwrap().contains("want array")); + // Check cause is now a JSON object + let cause_null = &null_errors[0]["details"]["cause"]; + assert!(cause_null.is_object()); + assert_eq!(cause_null["got"], "null"); + assert_eq!(cause_null["want"], json!(["array"])); // Test 2: Validate object against array schema let object_instance = json!({"id": "not-an-array"}); let object_result = validate_json_schema(schema_id, jsonb(object_instance.clone())); - assert_failure_with_json!(object_result, 1, "Field type does not match the expected type"); + assert_failure_with_json!(object_result, 1, "Expected array but got object"); let object_errors = object_result.0["errors"].as_array().unwrap(); assert_eq!(object_errors[0]["code"], "TYPE_MISMATCH"); assert_eq!(object_errors[0]["details"]["path"], ""); // Root level path should be empty string assert_eq!(object_errors[0]["details"]["context"], object_instance); assert_eq!(object_errors[0]["details"]["schema"], "array_schema"); + // Check cause is now a JSON object + let cause_object = &object_errors[0]["details"]["cause"]; + assert!(cause_object.is_object()); + assert_eq!(cause_object["got"], "object"); + assert_eq!(cause_object["want"], json!(["array"])); // Test 3: Valid empty array let valid_empty = json!([]); @@ -454,12 +480,17 @@ fn test_root_level_type_mismatch() { // String at root when object expected let string_instance = json!("not an object"); let string_result = validate_json_schema(object_schema_id, jsonb(string_instance)); - assert_failure_with_json!(string_result, 1, "Field type does not match the expected type"); + assert_failure_with_json!(string_result, 1, "Expected object but got string"); let string_errors = string_result.0["errors"].as_array().unwrap(); assert_eq!(string_errors[0]["code"], "TYPE_MISMATCH"); assert_eq!(string_errors[0]["details"]["path"], ""); // Root level path assert_eq!(string_errors[0]["details"]["schema"], "object_schema"); assert_eq!(string_errors[0]["details"]["context"], json!("not an object")); + // Check cause is now a JSON object + let cause_string = &string_errors[0]["details"]["cause"]; + assert!(cause_string.is_object()); + assert_eq!(cause_string["got"], "string"); + assert_eq!(cause_string["want"], json!(["object"])); } #[pg_test] @@ -534,11 +565,15 @@ fn test_auto_strict_validation() { // Should fail with strict schema let result_root_strict = validate_json_schema(schema_id, jsonb(invalid_root_extra.clone())); - assert_failure_with_json!(result_root_strict, 1, "Schema validation always fails"); + assert_failure_with_json!(result_root_strict, 1, "This schema always fails validation"); let errors_root = result_root_strict.0["errors"].as_array().unwrap(); assert_eq!(errors_root[0]["code"], "FALSE_SCHEMA"); assert_eq!(errors_root[0]["details"]["path"], "/extraField"); assert_eq!(errors_root[0]["details"]["schema"], "strict_test"); + // Check cause is now a JSON object (empty for FalseSchema) + let cause_root = &errors_root[0]["details"]["cause"]; + assert!(cause_root.is_object()); + assert_eq!(cause_root, &json!({})); // Should pass with non-strict schema let result_root_non_strict = validate_json_schema(schema_id_non_strict, jsonb(invalid_root_extra)); @@ -555,7 +590,7 @@ fn test_auto_strict_validation() { // Should fail with strict schema let result_nested_strict = validate_json_schema(schema_id, jsonb(invalid_nested_extra.clone())); - assert_failure_with_json!(result_nested_strict, 1, "Schema validation always fails"); + assert_failure_with_json!(result_nested_strict, 1, "This schema always fails validation"); let errors_nested = result_nested_strict.0["errors"].as_array().unwrap(); assert_eq!(errors_nested[0]["code"], "FALSE_SCHEMA"); assert_eq!(errors_nested[0]["details"]["path"], "/profile/extraNested"); @@ -579,7 +614,7 @@ fn test_auto_strict_validation() { // Should fail with strict schema let result_deep_strict = validate_json_schema(schema_id, jsonb(invalid_deep_extra.clone())); - assert_failure_with_json!(result_deep_strict, 1, "Schema validation always fails"); + assert_failure_with_json!(result_deep_strict, 1, "This schema always fails validation"); let errors_deep = result_deep_strict.0["errors"].as_array().unwrap(); assert_eq!(errors_deep[0]["code"], "FALSE_SCHEMA"); assert_eq!(errors_deep[0]["details"]["path"], "/profile/preferences/extraDeep"); @@ -599,7 +634,7 @@ fn test_auto_strict_validation() { // Should fail with strict schema let result_array_strict = validate_json_schema(schema_id, jsonb(invalid_array_item_extra.clone())); - assert_failure_with_json!(result_array_strict, 1, "Schema validation always fails"); + assert_failure_with_json!(result_array_strict, 1, "This schema always fails validation"); let errors_array = result_array_strict.0["errors"].as_array().unwrap(); assert_eq!(errors_array[0]["code"], "FALSE_SCHEMA"); assert_eq!(errors_array[0]["details"]["path"], "/tags/0/extraInArray"); @@ -680,7 +715,7 @@ fn test_auto_strict_validation() { }); let result_invalid_conditional = validate_json_schema(schema_id_conditional, jsonb(invalid_conditional)); - assert_failure_with_json!(result_invalid_conditional, 1, "Schema validation always fails"); + assert_failure_with_json!(result_invalid_conditional, 1, "This schema always fails validation"); let errors_conditional = result_invalid_conditional.0["errors"].as_array().unwrap(); assert_eq!(errors_conditional[0]["code"], "FALSE_SCHEMA"); assert_eq!(errors_conditional[0]["details"]["path"], "/extra"); @@ -1116,7 +1151,7 @@ fn test_unevaluated_properties_errors() { let result = validate_json_schema(schema_id, jsonb(instance_uneval)); // Should get 3 separate FALSE_SCHEMA errors, one for each unevaluated property - assert_failure_with_json!(result, 3, "Schema validation always fails"); + assert_failure_with_json!(result, 3, "This schema always fails validation"); let errors = result.0["errors"].as_array().unwrap(); @@ -1177,7 +1212,7 @@ fn test_unevaluated_properties_errors() { let complex_result = validate_json_schema(complex_schema_id, jsonb(complex_instance)); // Should get 2 FALSE_SCHEMA errors for unevaluated properties - assert_failure_with_json!(complex_result, 2, "Schema validation always fails"); + assert_failure_with_json!(complex_result, 2, "This schema always fails validation"); let complex_errors = complex_result.0["errors"].as_array().unwrap();