1use graphrt_core::pool::{Selector, VariablePool};
15use graphrt_core::template::Template;
16use graphrt_core::value::Value;
17
18pub fn render_config(
20 config: &serde_json::Map<String, serde_json::Value>,
21 pool: &VariablePool,
22 expose_secrets: bool,
23) -> serde_json::Value {
24 serde_json::Value::Object(render_object(config, pool, expose_secrets))
25}
26
27pub fn collect_selectors(config: &serde_json::Map<String, serde_json::Value>) -> Vec<Selector> {
29 let mut out = Vec::new();
30 collect_object(config, &mut out);
31 out
32}
33
34fn to_json(value: &Value, expose_secrets: bool) -> serde_json::Value {
35 if expose_secrets { value.to_json_exposed() } else { value.to_json() }
36}
37
38fn render_object(
39 map: &serde_json::Map<String, serde_json::Value>,
40 pool: &VariablePool,
41 expose: bool,
42) -> serde_json::Map<String, serde_json::Value> {
43 let mut out = serde_json::Map::with_capacity(map.len());
44 for (key, value) in map {
45 out.insert(key.clone(), render_value(value, pool, expose));
46 }
47 for (key, value) in map {
49 if let serde_json::Value::String(s) = value {
50 if has_placeholder(s) {
51 let raw_key = format!("{key}_raw");
52 if !out.contains_key(&raw_key) {
53 out.insert(raw_key, value.clone());
54 }
55 }
56 }
57 if key.ends_with("selector") {
58 if let Some(selector) = as_selector(value) {
59 let value_key = format!("{key}_value");
60 if !out.contains_key(&value_key) {
61 let resolved = pool.get(&selector).map(|v| to_json(&v, expose)).unwrap_or(serde_json::Value::Null);
62 out.insert(value_key, resolved);
63 }
64 }
65 }
66 }
67 out
68}
69
70fn render_value(value: &serde_json::Value, pool: &VariablePool, expose: bool) -> serde_json::Value {
71 match value {
72 serde_json::Value::String(s) if has_placeholder(s) => {
73 let template = Template::parse(s);
74 if template.is_static() {
75 return value.clone();
76 }
77 match template.parts() {
78 [graphrt_core::template::Part::Var(_)] => to_json(&template.resolve(pool), expose),
79 _ => {
80 let text = if expose { template.render_exposed(pool) } else { template.render(pool) };
81 serde_json::Value::String(text)
82 }
83 }
84 }
85 serde_json::Value::Object(map) => serde_json::Value::Object(render_object(map, pool, expose)),
86 serde_json::Value::Array(items) => {
87 serde_json::Value::Array(items.iter().map(|v| render_value(v, pool, expose)).collect())
88 }
89 other => other.clone(),
90 }
91}
92
93fn collect_object(map: &serde_json::Map<String, serde_json::Value>, out: &mut Vec<Selector>) {
94 for (key, value) in map {
95 if key.ends_with("selector") {
96 if let Some(selector) = as_selector(value) {
97 out.push(selector);
98 continue;
99 }
100 }
101 collect_value(value, out);
102 }
103}
104
105fn collect_value(value: &serde_json::Value, out: &mut Vec<Selector>) {
106 match value {
107 serde_json::Value::String(s) if has_placeholder(s) => {
108 out.extend(Template::parse(s).selectors().cloned());
109 }
110 serde_json::Value::Object(map) => collect_object(map, out),
111 serde_json::Value::Array(items) => items.iter().for_each(|v| collect_value(v, out)),
112 _ => {}
113 }
114}
115
116fn has_placeholder(s: &str) -> bool {
117 s.contains("{{#")
118}
119
120fn as_selector(value: &serde_json::Value) -> Option<Selector> {
122 match value {
123 serde_json::Value::Array(items) => {
124 let parts: Option<Vec<&str>> = items.iter().map(serde_json::Value::as_str).collect();
125 parts.filter(|p| p.len() >= 2).and_then(|p| Selector::new(p).ok())
126 }
127 serde_json::Value::String(s) if !s.chars().any(char::is_whitespace) && s.contains('.') => {
128 Selector::parse(s).ok()
129 }
130 _ => None,
131 }
132}
133
134#[cfg(test)]
135mod tests {
136 use std::sync::Arc;
137
138 use super::*;
139
140 fn pool() -> VariablePool {
141 let mut p = VariablePool::new();
142 p.insert("start", "name", Value::from("Ada"));
143 p.insert("start", "n", Value::Int(3));
144 p.insert("env", "KEY", Value::Secret(Arc::from("s3cret")));
145 p
146 }
147
148 fn cfg(v: serde_json::Value) -> serde_json::Map<String, serde_json::Value> {
149 v.as_object().cloned().unwrap()
150 }
151
152 #[test]
153 fn renders_templates_and_selectors() {
154 let c = cfg(serde_json::json!({
155 "greeting": "hi {{#start.name#}}",
156 "count": "{{#start.n#}}",
157 "plain": "no vars",
158 "value_selector": ["start", "name"],
159 "nested": [{"query_selector": "start.n"}],
160 "missing_selector": ["start", "nope"]
161 }));
162 let out = render_config(&c, &pool(), false);
163 assert_eq!(out["greeting"], "hi Ada");
164 assert_eq!(out["greeting_raw"], "hi {{#start.name#}}");
165 assert_eq!(out["count"], 3);
166 assert_eq!(out["plain"], "no vars");
167 assert!(out.get("plain_raw").is_none());
168 assert_eq!(out["value_selector_value"], "Ada");
169 assert_eq!(out["nested"][0]["query_selector_value"], 3);
170 assert_eq!(out["missing_selector_value"], serde_json::Value::Null);
171 }
172
173 #[test]
174 fn masks_secrets_unless_exposed() {
175 let c = cfg(serde_json::json!({"key": "{{#env.KEY#}}", "auth": "Bearer {{#env.KEY#}}"}));
176 let masked = render_config(&c, &pool(), false);
177 assert_eq!(masked["key"], "******");
178 assert!(!masked.to_string().contains("s3cret"));
179 let exposed = render_config(&c, &pool(), true);
180 assert_eq!(exposed["auth"], "Bearer s3cret");
181 }
182
183 #[test]
184 fn collects_references() {
185 let c = cfg(serde_json::json!({
186 "a": "{{#start.name#}} and {{#sys.query#}}",
187 "variable_selector": ["start", "n"],
188 "list": [{"x": "{{#llm.text#}}"}],
189 "title": "not.a.selector"
190 }));
191 let sels: Vec<String> = collect_selectors(&c).iter().map(ToString::to_string).collect();
192 assert_eq!(sels, ["start.name", "sys.query", "start.n", "llm.text"]);
193 }
194
195 #[test]
196 fn user_keys_win_over_siblings() {
197 let c = cfg(serde_json::json!({"value_selector": ["start", "name"], "value_selector_value": "mine"}));
198 assert_eq!(render_config(&c, &pool(), false)["value_selector_value"], "mine");
199 }
200}