1use graphrt_core::pool::{Selector, VariablePool};
17use graphrt_core::template::Template;
18use graphrt_core::value::Value;
19use serde_json::Value as Json;
20
21pub fn resolve_config(config: &Json, pool: &VariablePool, expose_secrets: bool) -> Json {
23 match config {
24 Json::String(s) => resolve_string(s, pool, expose_secrets),
25 Json::Array(items) => Json::Array(items.iter().map(|v| resolve_config(v, pool, expose_secrets)).collect()),
26 Json::Object(map) => {
27 let mut out = serde_json::Map::with_capacity(map.len());
28 for (key, value) in map {
29 if is_selector_key(key) {
30 if let Some(selector) = parse_selector(value) {
31 out.insert(key.clone(), value.clone());
32 let resolved = pool.get(&selector).map(|v| to_json(&v, expose_secrets)).unwrap_or(Json::Null);
33 out.insert(format!("{key}_value"), resolved);
34 continue;
35 }
36 }
37 out.insert(key.clone(), resolve_config(value, pool, expose_secrets));
38 }
39 Json::Object(out)
40 }
41 other => other.clone(),
42 }
43}
44
45pub fn collect_selectors(config: &Json, out: &mut Vec<Selector>) {
48 match config {
49 Json::String(s) if s.contains("{{#") => out.extend(Template::parse(s).selectors().cloned()),
50 Json::Array(items) => items.iter().for_each(|v| collect_selectors(v, out)),
51 Json::Object(map) => {
52 for (key, value) in map {
53 match parse_selector(value).filter(|_| is_selector_key(key)) {
54 Some(selector) => out.push(selector),
55 None => collect_selectors(value, out),
56 }
57 }
58 }
59 _ => {}
60 }
61}
62
63fn resolve_string(s: &str, pool: &VariablePool, expose_secrets: bool) -> Json {
64 if !s.contains("{{#") {
65 return Json::String(s.to_owned());
66 }
67 let template = Template::parse(s);
68 if template.is_static() {
69 return Json::String(s.to_owned());
70 }
71 if let [graphrt_core::template::Part::Var(selector)] = template.parts() {
72 return pool.get(selector).map(|v| to_json(&v, expose_secrets)).unwrap_or(Json::Null);
73 }
74 let text = if expose_secrets { template.render_exposed(pool) } else { template.render(pool) };
75 Json::String(text)
76}
77
78fn to_json(value: &Value, expose_secrets: bool) -> Json {
79 if expose_secrets { value.to_json_exposed() } else { value.to_json() }
80}
81
82fn is_selector_key(key: &str) -> bool {
83 key.ends_with("selector")
84}
85
86fn parse_selector(value: &Json) -> Option<Selector> {
87 match value {
88 Json::Array(parts) => {
89 let parts: Option<Vec<&str>> = parts.iter().map(Json::as_str).collect();
90 Selector::new(parts?).ok()
91 }
92 Json::String(s) if s.contains('.') && !s.contains("{{") => Selector::parse(s).ok(),
93 _ => None,
94 }
95}
96
97#[cfg(test)]
98mod tests {
99 use std::sync::Arc;
100
101 use super::*;
102
103 fn pool() -> VariablePool {
104 let mut p = VariablePool::new();
105 p.insert("start", "name", Value::from("Ada"));
106 p.insert("start", "n", Value::Int(3));
107 p.insert("env", "KEY", Value::Secret(Arc::from("sk-1")));
108 p
109 }
110
111 #[test]
112 fn resolves_placeholders_and_selectors() {
113 let cfg = serde_json::json!({
114 "text": "Hi {{#start.name#}}",
115 "count": "{{#start.n#}}",
116 "input_selector": ["start", "name"],
117 "nested": [{"value_selector": "start.n"}],
118 "missing": "{{#start.nope#}}",
119 "plain": "no placeholders",
120 });
121 let out = resolve_config(&cfg, &pool(), false);
122 assert_eq!(out["text"], "Hi Ada");
123 assert_eq!(out["count"], 3);
124 assert_eq!(out["input_selector_value"], "Ada");
125 assert_eq!(out["nested"][0]["value_selector_value"], 3);
126 assert_eq!(out["missing"], Json::Null);
127 assert_eq!(out["plain"], "no placeholders");
128 }
129
130 #[test]
131 fn secrets_masked_unless_exposed() {
132 let cfg = serde_json::json!({"key": "{{#env.KEY#}}", "auth": "Bearer {{#env.KEY#}}"});
133 let masked = resolve_config(&cfg, &pool(), false);
134 assert_ne!(masked["key"], "sk-1");
135 assert!(!masked["auth"].as_str().unwrap_or_default().contains("sk-1"));
136 let exposed = resolve_config(&cfg, &pool(), true);
137 assert_eq!(exposed["key"], "sk-1");
138 assert_eq!(exposed["auth"], "Bearer sk-1");
139 }
140
141 #[test]
142 fn collects_references() {
143 let cfg =
144 serde_json::json!({"a": "{{#x.y#}} {{#z.w#}}", "b_selector": ["q", "r"], "c": [{"value_selector": "m.n"}]});
145 let mut out = Vec::new();
146 collect_selectors(&cfg, &mut out);
147 let names: Vec<String> = out.iter().map(ToString::to_string).collect();
148 assert_eq!(names, ["x.y", "z.w", "q.r", "m.n"]);
149 }
150}