#![allow(unused_imports)]
use super::*;
pub(super) fn validate_primitive(
_registry: &TypeLattice,
type_name: &str,
raw_value: &str,
parsed: &JsonValue,
schema: &serde_yaml::Value,
_level: u8,
) -> Result<(), TypeValidationError> {
let constraints = schema.get("constraints").cloned().unwrap_or(serde_yaml::Value::Null);
if let Some(pattern) = constraints.get("pattern").and_then(|v| v.as_str())
&& pattern != "null" && !pattern.is_empty() {
let re = Regex::new(pattern).map_err(|e| {
TypeValidationError::StructuralError {
type_name: type_name.to_string(),
reason: format!("invalid regex '{}': {}", pattern, e),
}
})?;
if !re.is_match(raw_value) {
return Err(TypeValidationError::PatternViolation {
type_name: type_name.to_string(),
value: raw_value.to_string(),
pattern: pattern.to_string(),
});
}
}
if let Some(type_check) = constraints.get("type_check").and_then(|v| v.as_str())
&& type_check != "null" {
match type_check {
"is_integer" => {
if !Regex::new(r"^-?[0-9]+$")
.unwrap()
.is_match(raw_value)
{
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "integer".to_string(),
});
}
}
"is_boolean" => {
let lower = raw_value.to_lowercase();
if lower != "true" && lower != "false" {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "boolean".to_string(),
});
}
}
"is_string" => {
if parsed.is_object() || parsed.is_array() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "string".to_string(),
});
}
if Regex::new(r"^-?[0-9]+(\.[0-9]+)?$").unwrap().is_match(raw_value)
|| ["true", "false"].contains(&lower_cased(raw_value).as_str())
{
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "string".to_string(),
});
}
}
"is_list" => {
if !parsed.is_array() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "list".to_string(),
});
}
}
"is_map" => {
if !parsed.is_object() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "map".to_string(),
});
}
}
"is_process_payload"
if !parsed.is_object() && !parsed.is_array() => {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "process payload".to_string(),
});
}
_ => {}
}
}
Ok(())
}
pub(super) fn validate_type_check(
type_name: &str,
raw_value: &str,
parsed: &JsonValue,
schema: &serde_yaml::Value,
) -> Result<(), TypeValidationError> {
let constraints = schema.get("constraints").cloned().unwrap_or(serde_yaml::Value::Null);
if let Some(type_check) = constraints.get("type_check").and_then(|v| v.as_str())
&& type_check != "null" {
match type_check {
"is_integer" => {
static INT_RE: OnceLock<Regex> = OnceLock::new();
let re = INT_RE.get_or_init(|| Regex::new(r"^-?[0-9]+$").unwrap());
if !re.is_match(raw_value) {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "integer".to_string(),
});
}
}
"is_boolean" => {
let lower = raw_value.to_lowercase();
if lower != "true" && lower != "false" {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "boolean".to_string(),
});
}
}
"is_string" => {
if parsed.is_object() || parsed.is_array() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "string".to_string(),
});
}
static NUM_RE: OnceLock<Regex> = OnceLock::new();
let num_re = NUM_RE.get_or_init(|| Regex::new(r"^-?[0-9]+(\.[0-9]+)?$").unwrap());
if num_re.is_match(raw_value)
|| ["true", "false"].contains(&lower_cased(raw_value).as_str())
{
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "string".to_string(),
});
}
}
"is_list" => {
if !parsed.is_array() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "list".to_string(),
});
}
}
"is_map" => {
if !parsed.is_object() {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "map".to_string(),
});
}
}
"is_process_payload"
if !parsed.is_object() && !parsed.is_array() => {
return Err(TypeValidationError::TypeCheckFailure {
type_name: type_name.to_string(),
value: raw_value.to_string(),
expected: "process payload".to_string(),
});
}
_ => {}
}
}
Ok(())
}
pub(super) fn validate_field_list(
registry: &TypeLattice,
type_name: &str,
parsed: &JsonValue,
schema: &serde_yaml::Value,
level: u8,
) -> Result<(), TypeValidationError> {
let map = parsed.as_object().ok_or_else(|| TypeValidationError::StructuralError {
type_name: type_name.to_string(),
reason: "value is not a map/object".to_string(),
})?;
let required = schema.get("required_fields").and_then(|v| v.as_sequence()).cloned().unwrap_or_default();
let optional = schema.get("optional_fields").and_then(|v| v.as_sequence()).cloned().unwrap_or_default();
for field in &required {
let f_name = field.get("name").and_then(|v| v.as_str()).unwrap_or("");
let f_type = field.get("type").and_then(|v| v.as_str()).unwrap_or("");
let value = map.get(f_name).ok_or_else(|| TypeValidationError::MissingRequiredField {
type_name: type_name.to_string(),
field: f_name.to_string(),
})?;
registry.validate(f_type, &json_to_str(value), level)?;
check_enum(type_name, f_name, value, field)?;
}
for field in &optional {
let f_name = field.get("name").and_then(|v| v.as_str()).unwrap_or("");
let f_type = field.get("type").and_then(|v| v.as_str()).unwrap_or("");
if let Some(value) = map.get(f_name)
&& !value.is_null() && json_to_str(value) != "null" {
registry.validate(f_type, &json_to_str(value), level)?;
check_enum(type_name, f_name, value, field)?;
}
}
Ok(())
}
pub(super) fn validate_json_schema(
registry: &TypeLattice,
type_name: &str,
parsed: &JsonValue,
schema: &serde_yaml::Value,
level: u8,
) -> Result<(), TypeValidationError> {
let map = parsed.as_object().ok_or_else(|| TypeValidationError::StructuralError {
type_name: type_name.to_string(),
reason: "value is not a map/object".to_string(),
})?;
let required = schema.get("required").and_then(|v| v.as_sequence()).cloned().unwrap_or_default();
let properties = schema.get("properties").and_then(|v| v.as_mapping()).cloned().unwrap_or_default();
for f_name_value in required {
let f_name = f_name_value.as_str().unwrap_or("");
let value = map.get(f_name).ok_or_else(|| TypeValidationError::MissingRequiredField {
type_name: type_name.to_string(),
field: f_name.to_string(),
})?;
let f_info = properties.get(&f_name_value).cloned().unwrap_or(serde_yaml::Value::Null);
validate_json_schema_field(registry, type_name, f_name, value, &f_info, level)?;
}
Ok(())
}
pub(super) fn validate_json_schema_field(
registry: &TypeLattice,
type_name: &str,
_field: &str,
value: &JsonValue,
info: &serde_yaml::Value,
level: u8,
) -> Result<(), TypeValidationError> {
if let Some(pattern) = info.get("pattern").and_then(|v| v.as_str()) {
let re = Regex::new(pattern).map_err(|e| TypeValidationError::StructuralError {
type_name: type_name.to_string(),
reason: format!("invalid regex '{}': {}", pattern, e),
})?;
if !re.is_match(&json_to_str(value)) {
return Err(TypeValidationError::PatternViolation {
type_name: type_name.to_string(),
value: json_to_str(value),
pattern: pattern.to_string(),
});
}
}
if let Some(f_type) = info.get("type").and_then(|v| v.as_str()) {
let resolved = match f_type {
"array" => "list",
"object" => "map",
other => other,
};
registry.validate(resolved, &json_to_str(value), level)?;
}
Ok(())
}
pub(super) fn check_enum(
type_name: &str,
field: &str,
value: &JsonValue,
field_spec: &serde_yaml::Value,
) -> Result<(), TypeValidationError> {
if let Some(en) = field_spec.get("constraints").and_then(|v| v.get("enum")).and_then(|v| v.as_sequence()) {
let val_str = json_to_str(value);
let allowed: Vec<String> = en.iter().map(yaml_to_str).collect();
if !allowed.contains(&val_str) {
return Err(TypeValidationError::EnumViolation {
type_name: type_name.to_string(),
field: field.to_string(),
value: val_str,
});
}
}
Ok(())
}
pub(super) fn json_to_str(value: &JsonValue) -> String {
match value {
JsonValue::String(s) => s.clone(),
JsonValue::Number(n) => n.to_string(),
JsonValue::Bool(b) => b.to_string(),
JsonValue::Null => "null".to_string(),
other => other.to_string(),
}
}
pub(super) fn yaml_to_str(value: &serde_yaml::Value) -> String {
match value {
serde_yaml::Value::String(s) => s.clone(),
serde_yaml::Value::Number(n) => n.to_string(),
serde_yaml::Value::Bool(b) => b.to_string(),
serde_yaml::Value::Null => "null".to_string(),
other => serde_yaml::to_string(other).unwrap_or_default().trim().to_string(),
}
}
pub(super) fn lower_cased(s: &str) -> String {
s.to_lowercase()
}