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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Root data contract document.

use serde::{Deserialize, Serialize};

use super::fundamentals::ContractDescription;
use super::pricing::Pricing;
use super::quality::DataQuality;
use super::roles::Role;
use super::schema::SchemaObject;
use super::servers::Server;
use super::shared::{AuthoritativeDefinitions, CustomProperties, Tags};
use super::sla::ServiceLevelAgreementProperty;
use super::support::Support;
use super::team::TeamDeclaration;
use super::versioning::is_supported_api_version;

/// An ODCS Data Contract — the canonical root object.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DataContract {
    /// ODCS document revision (contract version, e.g. `1.0.0`).
    pub version: String,
    /// ODCS API version.
    pub api_version: String,
    /// Document kind (typically `DataContract`).
    pub kind: String,
    /// Stable contract identifier.
    pub id: String,
    /// Contract lifecycle status.
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Tags>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub servers: Vec<Server>,
    /// Deprecated data product name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data_product: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<ContractDescription>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub domain: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub schema: Vec<SchemaObject>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub support: Option<Support>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price: Option<Pricing>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team: Option<TeamDeclaration>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub roles: Vec<Role>,
    /// Deprecated SLA default element.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sla_default_element: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub sla_properties: Vec<ServiceLevelAgreementProperty>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authoritative_definitions: Option<AuthoritativeDefinitions>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom_properties: Option<CustomProperties>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub contract_created_ts: Option<String>,
}

impl DataContract {
    /// Returns `true` when the API version is supported by this crate.
    #[must_use]
    pub fn is_supported_api_version(&self) -> bool {
        is_supported_api_version(&self.api_version)
    }

    /// Returns all nested quality rules declared on schema objects and properties.
    #[must_use]
    pub fn quality_rules(&self) -> Vec<&DataQuality> {
        let mut rules = Vec::new();
        for schema in &self.schema {
            if let Some(ref quality) = schema.quality {
                rules.extend(quality.iter());
            }
            collect_property_quality(&schema.properties, &mut rules);
        }
        rules
    }
}

fn collect_property_quality<'a>(
    properties: &'a [super::schema::SchemaProperty],
    out: &mut Vec<&'a DataQuality>,
) {
    for property in properties {
        if let Some(ref quality) = property.quality {
            out.extend(quality.iter());
        }
        if !property.properties.is_empty() {
            collect_property_quality(&property.properties, out);
        }
        if let Some(items) = &property.items {
            collect_property_quality(std::slice::from_ref(items), out);
        }
    }
}