dtcs 0.2.0

Reference implementation of the Data Transformation Contract Standard (DTCS)
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Reference validation phase.

use crate::diagnostics::{codes, DiagnosticCategory};
use crate::model::TransformationContract;

use super::context::ValidationContext;
use super::field_index::{FieldIndex, TargetResolution};
use super::lineage::validate_lineage;

pub(crate) fn validate_references(ctx: &mut ValidationContext, contract: &TransformationContract) {
    let index = FieldIndex::from_contract(contract);

    validate_lineage(ctx, contract);

    for action in &contract.semantic_actions {
        if action.action.trim().is_empty() {
            ctx.error(
                codes::MISSING_REQUIRED_FIELD,
                DiagnosticCategory::Reference,
                "semantic action registry identifier is required",
                Some(&format!("semanticActions.{}", action.id)),
                Some("Set action to a namespaced semantic action identifier"),
            );
        }
        if action.target.trim().is_empty() {
            ctx.error(
                codes::MISSING_REQUIRED_FIELD,
                DiagnosticCategory::Reference,
                "semantic action target is required",
                Some(&format!("semanticActions.{}", action.id)),
                None,
            );
            continue;
        }
        resolve_target(
            ctx,
            &action.target,
            &format!("semanticActions.{}.target", action.id),
            true,
            &index,
        );
    }

    for rule in &contract.rules {
        if rule.rule.trim().is_empty() {
            ctx.error(
                codes::MISSING_REQUIRED_FIELD,
                DiagnosticCategory::Reference,
                "rule registry identifier is required",
                Some(&format!("rules.{}", rule.id)),
                None,
            );
        }
        if rule.target.trim().is_empty() {
            ctx.error(
                codes::MISSING_REQUIRED_FIELD,
                DiagnosticCategory::Reference,
                "rule target is required",
                Some(&format!("rules.{}", rule.id)),
                None,
            );
            continue;
        }
        resolve_target(
            ctx,
            &rule.target,
            &format!("rules.{}.target", rule.id),
            false,
            &index,
        );
    }

    for function in &contract.functions {
        if function.function.trim().is_empty() {
            ctx.error(
                codes::MISSING_REQUIRED_FIELD,
                DiagnosticCategory::Reference,
                "function registry identifier is required",
                Some(&format!("functions.{}", function.id)),
                None,
            );
        }
    }
}

fn resolve_target(
    ctx: &mut ValidationContext,
    target: &str,
    object_ref: &str,
    allow_interface: bool,
    index: &FieldIndex,
) {
    match index.resolve(target) {
        TargetResolution::Field(_) => {}
        TargetResolution::Interface { .. } if allow_interface => {}
        TargetResolution::Interface { .. } => {
            ctx.error(
                codes::UNRESOLVED_REFERENCE,
                DiagnosticCategory::Reference,
                format!("target '{target}' must reference a schema field"),
                Some(object_ref),
                Some("Target a declared schema field or use interface.field syntax"),
            );
        }
        TargetResolution::Ambiguous(_) => {
            ctx.error(
                codes::AMBIGUOUS_REFERENCE,
                DiagnosticCategory::Reference,
                format!("target '{target}' matches multiple schema fields"),
                Some(object_ref),
                Some("Qualify the target with an interface identifier"),
            );
        }
        TargetResolution::NotFound => {
            ctx.error(
                codes::UNRESOLVED_REFERENCE,
                DiagnosticCategory::Reference,
                format!("target '{target}' is not declared"),
                Some(object_ref),
                Some("Target a declared schema field or interface identifier"),
            );
        }
    }
}