Function validate_compiled 

pub fn validate_compiled(
    compiled: &CompiledSchema,
    object: &Value,
    old_object: Option<&Value>,
) -> Vec<ValidationError>

Available on crate feature validation only.

Convenience function to validate using a pre-compiled schema.

Uses a thread-local Validator to avoid re-registering CEL functions on each call.

See Validator::validate_compiled for details.

Examples found in repository

examples/compiled_schema.rs (line 45)

fn main() {
    let schema = json!({
        "type": "object",
        "properties": {
            "spec": {
                "type": "object",
                "x-kubernetes-validations": [{
                    "rule": "self.replicas >= self.minReplicas",
                    "message": "replicas must be >= minReplicas",
                    "messageExpression": "'replicas is ' + string(self.replicas) + ' but minReplicas is ' + string(self.minReplicas)"
                }],
                "properties": {
                    "replicas": {
                        "type": "integer",
                        "x-kubernetes-validations": [
                            {"rule": "self >= 0", "message": "must be non-negative"}
                        ]
                    },
                    "minReplicas": {"type": "integer"}
                }
            }
        }
    });

    // Compile once
    let compiled = compile_schema(&schema);
    println!("Schema compiled successfully.\n");

    // Validate many objects
    let objects = [
        json!({"spec": {"replicas": 3, "minReplicas": 1}}),
        json!({"spec": {"replicas": -1, "minReplicas": 0}}),
        json!({"spec": {"replicas": 1, "minReplicas": 5}}),
        json!({"spec": {"replicas": 10, "minReplicas": 2}}),
    ];

    for (i, obj) in objects.iter().enumerate() {
        let errors = validate_compiled(&compiled, obj, None);
        let replicas = obj["spec"]["replicas"].as_i64().unwrap();
        let min = obj["spec"]["minReplicas"].as_i64().unwrap();
        if errors.is_empty() {
            println!("Object {i}: replicas={replicas}, min={min} -> OK");
        } else {
            println!(
                "Object {i}: replicas={replicas}, min={min} -> {} error(s)",
                errors.len()
            );
            for err in &errors {
                println!("  [{path}] {msg}", path = err.field_path, msg = err.message);
            }
        }
    }
}

examples/timestamp_duration.rs (line 77)

fn main() {
    // Schema with date-time and duration formats
    let schema = json!({
        "type": "object",
        "properties": {
            "spec": {
                "type": "object",
                "properties": {
                    "expiresAt": {
                        "type": "string",
                        "format": "date-time"
                    },
                    "timeout": {
                        "type": "string",
                        "format": "duration"
                    }
                },
                "x-kubernetes-validations": [
                    {
                        "rule": "self.expiresAt > timestamp('2024-01-01T00:00:00Z')",
                        "message": "must expire after 2024-01-01"
                    },
                    {
                        "rule": "self.timeout <= duration('1h')",
                        "message": "timeout must be at most 1 hour"
                    }
                ]
            }
        }
    });

    // ── Schema-based validation ──────────────────────────────────────

    println!("=== Schema-based validation ===\n");

    let valid = json!({
        "spec": {
            "expiresAt": "2025-06-15T12:00:00Z",
            "timeout": "30m"
        }
    });
    let errors = validate(&schema, &valid, None);
    println!("Valid object: {} errors", errors.len());

    let invalid = json!({
        "spec": {
            "expiresAt": "2023-06-15T12:00:00Z",
            "timeout": "2h"
        }
    });
    let errors = validate(&schema, &invalid, None);
    println!("Invalid object: {} errors", errors.len());
    for err in &errors {
        println!("  [{path}] {msg}", path = err.field_path, msg = err.message);
    }

    // ── Compiled schema (pre-compile once, validate many) ────────────

    println!("\n=== Compiled schema validation ===\n");

    let compiled = compile_schema(&schema);

    let objects = [
        json!({"spec": {"expiresAt": "2025-01-01T00:00:00Z", "timeout": "30s"}}),
        json!({"spec": {"expiresAt": "2023-12-31T23:59:59Z", "timeout": "45m"}}),
        json!({"spec": {"expiresAt": "2025-06-15T00:00:00Z", "timeout": "90m"}}),
    ];

    for (i, obj) in objects.iter().enumerate() {
        let errors = validate_compiled(&compiled, obj, None);
        if errors.is_empty() {
            println!("Object {i}: OK");
        } else {
            println!("Object {i}: {} error(s)", errors.len());
            for err in &errors {
                println!("  [{path}] {msg}", path = err.field_path, msg = err.message);
            }
        }
    }

    // ── Transition rule with timestamps ──────────────────────────────

    println!("\n=== Transition rule (expiration cannot move earlier) ===\n");

    let transition_schema = json!({
        "type": "object",
        "properties": {
            "expiresAt": {
                "type": "string",
                "format": "date-time"
            }
        },
        "x-kubernetes-validations": [{
            "rule": "self.expiresAt >= oldSelf.expiresAt",
            "message": "expiration cannot be moved earlier"
        }]
    });

    let new_obj = json!({"expiresAt": "2025-12-01T00:00:00Z"});
    let old_obj = json!({"expiresAt": "2025-06-01T00:00:00Z"});

    let errors = validate(&transition_schema, &new_obj, Some(&old_obj));
    println!("Extend expiration: {} errors", errors.len());

    let bad_obj = json!({"expiresAt": "2025-01-01T00:00:00Z"});
    let errors = validate(&transition_schema, &bad_obj, Some(&old_obj));
    println!("Shorten expiration: {} errors", errors.len());
    for err in &errors {
        println!("  {err}");
    }
}