greentic-flow-dev 1.1.27665160846

Generic YGTC flow schema/loader/IR for self-describing component nodes.
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
125
126
127
128
129
130
131
132
133
134
135
136

use ciborium::value::Value as CborValue;
use greentic_types::schemas::common::schema_ir::{AdditionalProperties, SchemaIr};

pub fn medium_flow_yaml() -> String {
    let mut yaml = String::from("id: perf_flow\ntype: messaging\nnodes:\n");
    for idx in 0..24 {
        let node_id = format!("node_{idx:02}");
        let next_id = if idx + 1 < 24 {
            format!("node_{:02}", idx + 1)
        } else {
            "done".to_string()
        };
        let component = if idx % 2 == 0 {
            "qa.process"
        } else {
            "template"
        };
        yaml.push_str(&format!("  {node_id}:\n"));
        match component {
            "qa.process" => {
                yaml.push_str("    qa.process:\n");
                yaml.push_str(&format!("      prompt: \"node {idx}\"\n"));
            }
            _ => {
                yaml.push_str(&format!("    template: \"node {idx}\"\n"));
            }
        }
        yaml.push_str("    routing:\n");
        if idx % 3 == 0 {
            yaml.push_str("      - status: ok\n");
            yaml.push_str(&format!("        to: {next_id}\n"));
            yaml.push_str("      - to: done\n");
        } else {
            yaml.push_str(&format!("      - to: {next_id}\n"));
        }
    }
    yaml.push_str("  done:\n");
    yaml.push_str("    template: \"done\"\n");
    yaml.push_str("    routing: out\n");
    yaml.push_str("start: node_00\n");
    yaml
}

#[allow(dead_code)]
pub fn nested_schema() -> SchemaIr {
    SchemaIr::Object {
        properties: std::collections::BTreeMap::from([
            (
                "name".to_string(),
                SchemaIr::String {
                    min_len: Some(3),
                    max_len: Some(64),
                    regex: None,
                    format: None,
                },
            ),
            ("enabled".to_string(), SchemaIr::Bool),
            (
                "retries".to_string(),
                SchemaIr::Int {
                    min: Some(0),
                    max: Some(10),
                },
            ),
            (
                "thresholds".to_string(),
                SchemaIr::Array {
                    items: Box::new(SchemaIr::Float {
                        min: Some(0.0),
                        max: Some(1.0),
                    }),
                    min_items: Some(2),
                    max_items: Some(8),
                },
            ),
            (
                "labels".to_string(),
                SchemaIr::Object {
                    properties: std::collections::BTreeMap::new(),
                    required: Vec::new(),
                    additional: AdditionalProperties::Schema(Box::new(SchemaIr::String {
                        min_len: Some(1),
                        max_len: Some(32),
                        regex: None,
                        format: None,
                    })),
                },
            ),
        ]),
        required: vec![
            "name".to_string(),
            "enabled".to_string(),
            "retries".to_string(),
        ],
        additional: AdditionalProperties::Forbid,
    }
}

#[allow(dead_code)]
pub fn nested_value() -> CborValue {
    CborValue::Map(vec![
        (
            CborValue::Text("name".to_string()),
            CborValue::Text("performance-check".to_string()),
        ),
        (
            CborValue::Text("enabled".to_string()),
            CborValue::Bool(true),
        ),
        (
            CborValue::Text("retries".to_string()),
            CborValue::Integer(3.into()),
        ),
        (
            CborValue::Text("thresholds".to_string()),
            CborValue::Array(vec![
                CborValue::Float(0.25),
                CborValue::Float(0.5),
                CborValue::Float(0.75),
            ]),
        ),
        (
            CborValue::Text("labels".to_string()),
            CborValue::Map(vec![
                (
                    CborValue::Text("team".to_string()),
                    CborValue::Text("flow".to_string()),
                ),
                (
                    CborValue::Text("env".to_string()),
                    CborValue::Text("ci".to_string()),
                ),
            ]),
        ),
    ])
}