odcs 0.9.1

Reference implementation of the Open Data Contract Standard (ODCS)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! JSON Schema validation against the pinned upstream ODCS schema.

use std::sync::OnceLock;

use jsonschema::Validator;
use serde_json::Value;

use crate::diagnostics::{
    codes, emit, validation_error, DiagnosticCategory, DiagnosticReport, ValidationPhase,
};
use crate::model::DataContract;
use crate::schema;

fn pinned_validator() -> &'static Validator {
    static VALIDATOR: OnceLock<Validator> = OnceLock::new();
    VALIDATOR.get_or_init(|| {
        jsonschema::validator_for(schema::pinned_schema_value())
            .expect("pinned ODCS JSON Schema must compile")
    })
}

/// Validate a contract instance against the pinned ODCS JSON Schema.
#[must_use]
pub fn validate(contract: &DataContract) -> DiagnosticReport {
    let mut report = DiagnosticReport::new();
    let instance = match serde_json::to_value(contract) {
        Ok(value) => value,
        Err(error) => {
            emit(
                &mut report,
                validation_error(
                    ValidationPhase::JsonSchema,
                    codes::JSON_SCHEMA_VIOLATION,
                    DiagnosticCategory::Structure,
                    format!("failed to serialize contract for JSON Schema validation: {error}"),
                ),
            );
            return report;
        }
    };
    validate_instance(&mut report, &instance);
    report
}

fn validate_instance(report: &mut DiagnosticReport, instance: &Value) {
    let validator = pinned_validator();
    for error in validator.iter_errors(instance) {
        let object_ref = error.instance_path.to_string();
        let object_ref = if object_ref.is_empty() {
            None
        } else {
            Some(object_ref)
        };
        let mut diagnostic = validation_error(
            ValidationPhase::JsonSchema,
            codes::JSON_SCHEMA_VIOLATION,
            DiagnosticCategory::Structure,
            error.to_string(),
        );
        if let Some(object_ref) = object_ref {
            diagnostic = diagnostic.with_object_ref(object_ref);
        }
        emit(report, diagnostic);
    }
}