cellular/jspg
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

serializing ErrorKind directly to drop error cause

Browse Source
This commit is contained in:
Alex Groleau
2025-06-17 18:55:16 -04:00
parent 2dd17f0b37
commit 5fbf64bac5
2 changed files with 516 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

718
src/lib.rs
View File

@ -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<Error>) {
}
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<Error>) {
}
}
// 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<Error> {
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::<Vec<_>>().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::<Vec<_>>()
}),
}]
}
fn handle_required_error(base_path: &str, want: &[&str]) -> Vec<Error> {
// 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<Error> {
// 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<str>]) -> Vec<Error> {
// 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<Error> {
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::<Vec<_>>()
.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<Error> {
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<Error> {
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<Error> {
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<str>, want: &str) -> Vec<Error> {
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<Number>, want: &Number) -> Vec<Error> {
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<Number>, want: &Number) -> Vec<Error> {
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<Number>, want: &Number) -> Vec<Error> {
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<Number>, want: &Number) -> Vec<Error> {
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<Number>, want: &Number) -> Vec<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Value>, err: &Box<dyn std::error::Error>) -> Vec<Error> {
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<Error> {
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<Error> {
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<Error> {
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::<Vec<_>>().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<Error> {
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::<Vec<_>>().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<dyn std::error::Error>) -> Vec<Error> {
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<dyn std::error::Error>) -> Vec<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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<Error> {
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