use std::marker::PhantomData;
use indexmap::IndexMap;
use crate::{InputType, InputValueError, Name, Value};
pub trait ValidatorExt<T: InputType> {
fn into_input_value_error(self) -> InputValueError<T>;
}
impl<T: InputType> ValidatorExt<T> for validator::ValidationErrors {
fn into_input_value_error(self) -> InputValueError<T> {
validation_errors_into_input_value_error(self)
}
}
pub struct ValidatorAdapter<T: InputType + validator::Validate> {
_phantom: PhantomData<T>,
}
impl<T: InputType + validator::Validate> ValidatorAdapter<T> {
pub fn new() -> Self {
Self {
_phantom: PhantomData,
}
}
}
impl<T: InputType + validator::Validate> Default for ValidatorAdapter<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: InputType + validator::Validate> crate::CustomValidator<T> for ValidatorAdapter<T> {
fn check(&self, value: &T) -> Result<(), InputValueError<T>> {
value
.validate()
.map_err(ValidatorExt::into_input_value_error)
}
}
fn validation_errors_into_input_value_error<T: InputType>(
errors: validator::ValidationErrors,
) -> InputValueError<T> {
let details = validation_error_details(&errors);
let mut err = InputValueError::custom(errors.to_string());
if !details.is_empty() {
err = err.with_extension("validation_errors", details);
}
err
}
fn validation_error_details(errors: &validator::ValidationErrors) -> Vec<Value> {
errors
.field_errors()
.iter()
.flat_map(|(field, field_errors)| {
field_errors.iter().map(move |field_error| {
let mut details = IndexMap::new();
details.insert(Name::new("field"), Value::from(field.to_string()));
details.insert(Name::new("code"), Value::from(field_error.code.to_string()));
if let Some(message) = &field_error.message {
details.insert(Name::new("message"), Value::from(message.to_string()));
}
Value::Object(details)
})
})
.collect()
}