clm-kernel 0.0.9

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![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(())
}

/// Standalone type_check validation (used by CompiledTypeLattice fast path).
/// Uses cached regexes via OnceLock to avoid recompilation on every call.
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()
}