Skip to main content

graphrt_plugin/
render.rs

1//! Resolving variables in plugin node configuration.
2//!
3//! Before a `node.run` request, the host rewrites the node's config:
4//!
5//! - strings containing `{{#ns.name#}}` placeholders are rendered (a string that is
6//!   exactly one placeholder becomes the typed value), and the original template
7//!   is kept under `<key>_raw`;
8//! - keys ending in `selector` holding a selector get a sibling `<key>_value` with
9//!   the selected value (`null` when missing).
10//!
11//! The same walk collects every referenced selector so the graph can validate
12//! references at load time.
13
14use graphrt_core::pool::{Selector, VariablePool};
15use graphrt_core::template::Template;
16use graphrt_core::value::Value;
17
18/// Render `config` against `pool`. Secrets are masked unless `expose_secrets`.
19pub 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
27/// Every selector referenced by `config`.
28pub 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    // Siblings are added after the walk so they never overwrite user keys.
48    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
120/// `["node","var",...]` or `"node.var"` (no whitespace).
121fn 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}