dc-runner-cli 0.2.12

Required Rust runner lane for Data Contracts.
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
125
126
127
128
129
130
131
132

use std::collections::HashMap;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ResolvedServiceImplementation {
    pub implementation_id: String,
    pub service_type: String,
    pub profile: String,
    pub imports: Vec<String>,
    pub packaging_mode: String,
}

fn key(service_type: &str, profile: &str) -> (String, String) {
    (service_type.to_string(), profile.to_string())
}

pub fn builtin_registry() -> HashMap<(String, String), ResolvedServiceImplementation> {
    let mut out = HashMap::new();
    out.insert(
        key("io.http", "request.http"),
        ResolvedServiceImplementation {
            implementation_id: "builtin.io.http.v1".to_string(),
            service_type: "io.http".to_string(),
            profile: "request.http".to_string(),
            imports: vec![
                "pipe_identity".to_string(),
                "assert_truth".to_string(),
                "get_json".to_string(),
                "post_json".to_string(),
            ],
            packaging_mode: "builtin".to_string(),
        },
    );
    out.insert(
        key("io.fs", "read.text"),
        ResolvedServiceImplementation {
            implementation_id: "builtin.io.fs.v1".to_string(),
            service_type: "io.fs".to_string(),
            profile: "read.text".to_string(),
            imports: vec![
                "pipe_identity".to_string(),
                "assert_truth".to_string(),
                "read_text".to_string(),
                "write_text".to_string(),
            ],
            packaging_mode: "builtin".to_string(),
        },
    );
    out.insert(
        key("io.system", "exec.command"),
        ResolvedServiceImplementation {
            implementation_id: "builtin.io.system.v1".to_string(),
            service_type: "io.system".to_string(),
            profile: "exec.command".to_string(),
            imports: vec![
                "pipe_identity".to_string(),
                "assert_truth".to_string(),
                "exec".to_string(),
                "now".to_string(),
            ],
            packaging_mode: "builtin".to_string(),
        },
    );
    out.insert(
        key("io.mysql", "mysql.query"),
        ResolvedServiceImplementation {
            implementation_id: "builtin.io.mysql.v1".to_string(),
            service_type: "io.mysql".to_string(),
            profile: "mysql.query".to_string(),
            imports: vec!["query".to_string(), "migrate".to_string()],
            packaging_mode: "builtin".to_string(),
        },
    );
    out.insert(
        key("io.docs", "generate.docs"),
        ResolvedServiceImplementation {
            implementation_id: "builtin.io.docs.v1".to_string(),
            service_type: "io.docs".to_string(),
            profile: "generate.docs".to_string(),
            imports: vec![
                "pipe_identity".to_string(),
                "assert_truth".to_string(),
                "render_docs".to_string(),
            ],
            packaging_mode: "builtin".to_string(),
        },
    );
    out
}

pub fn resolve_exact(
    service_type: &str,
    profile: &str,
) -> Result<ResolvedServiceImplementation, String> {
    let reg = builtin_registry();
    reg.get(&(service_type.to_string(), profile.to_string()))
        .cloned()
        .ok_or_else(|| {
            format!("runtime.services.unresolved_type_profile: {service_type}/{profile}")
        })
}

pub fn validate_imports_subset(
    impl_ref: &ResolvedServiceImplementation,
    declared_imports: &[String],
) -> Result<(), String> {
    for name in declared_imports {
        if !impl_ref.imports.iter().any(|allowed| allowed == name) {
            return Err(format!(
                "runtime.services.import_not_supported: {}:{}:{}",
                impl_ref.service_type, impl_ref.profile, name
            ));
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolve_exact_known_profile() {
        let resolved = resolve_exact("io.http", "request.http").expect("expected resolve");
        assert_eq!(resolved.implementation_id, "builtin.io.http.v1");
    }

    #[test]
    fn resolve_exact_unknown_profile_fails() {
        let err = resolve_exact("io.http", "unknown.profile").expect_err("expected fail");
        assert!(err.contains("runtime.services.unresolved_type_profile"));
    }
}