feat: support templating other types in default

danielorihuela · danielorihuela · commit aad8296c6d56 · 2026-04-20T12:25:16.000+02:00
diff --git a/agent-control/src/agent_type/render.rs b/agent-control/src/agent_type/render.rs
@@ -663,15 +663,22 @@ variables:
       description: "registry url"
       type: string
       required: false
-      default: "${nr-default:registry_url}"
+      default: "${nr-default:registry_url}/test-repository"
+    enable_file_logging:
+      description: "enable file logging"
+      type: bool
+      required: false
+      default: ${nr-default:enable_file_logging}
 deployment:
   linux:
+    enable_file_logging: ${nr-var:enable_file_logging}
     executables:
       - id: first
         path: /opt/first
         args:
           - "${nr-var:registry}"
   windows:
+    enable_file_logging: ${nr-var:enable_file_logging}
     executables:
       - id: first
         path: /opt/first
@@ -683,10 +690,16 @@ deployment:
         let values = testing_values("");
         let attributes = testing_agent_attributes(&agent_id);
 
-        let global_defaults = HashMap::from([(
-            "registry_url".to_string(),
-            serde_yaml::to_value("random-registry-url").unwrap(),
-        )]);
+        let global_defaults = HashMap::from([
+            (
+                "registry_url".to_string(),
+                serde_yaml::to_value("test-registry-url").unwrap(),
+            ),
+            (
+                "enable_file_logging".to_string(),
+                serde_yaml::to_value(true).unwrap(),
+            ),
+        ]);
 
         let renderer =
             TemplateRenderer::default().with_agent_control_variables(HashMap::new().into_iter());
@@ -701,14 +714,15 @@ deployment:
             )
             .unwrap();
         assert_eq!(
-            rendered::Args(vec!("random-registry-url".to_string())),
-            extract_runtime_by_environment(runtime_config)
+            rendered::Args(vec!("test-registry-url/test-repository".to_string())),
+            extract_runtime_by_environment(runtime_config.clone())
                 .executables
                 .first()
                 .unwrap()
                 .args
                 .clone()
         );
+        assert!(extract_runtime_by_environment(runtime_config.clone()).enable_file_logging);
     }
 
     #[test]
@@ -726,15 +740,22 @@ variables:
       description: "registry url"
       type: string
       required: false
-      default: "${nr-default:registry_url}"
+      default: "${nr-default:registry_url}/test-repository"
+    enable_file_logging:
+      description: "enable file logging"
+      type: bool
+      required: false
+      default: ${nr-default:enable_file_logging}
 deployment:
   linux:
+    enable_file_logging: ${nr-var:enable_file_logging}
     executables:
       - id: first
         path: /opt/first
         args:
           - "${nr-var:registry}"
   windows:
+    enable_file_logging: ${nr-var:enable_file_logging}
     executables:
       - id: first
         path: /opt/first
@@ -746,15 +767,27 @@ deployment:
         let values = testing_values("");
         let attributes = testing_agent_attributes(&agent_id);
 
-        let global_defaults = HashMap::from([(
-            "registry_url".to_string(),
-            serde_yaml::to_value("${nr-env:REGISTRY_URL}").unwrap(),
-        )]);
+        let global_defaults = HashMap::from([
+            (
+                "registry_url".to_string(),
+                serde_yaml::to_value("${nr-env:REGISTRY_URL}").unwrap(),
+            ),
+            (
+                "enable_file_logging".to_string(),
+                serde_yaml::to_value("${nr-env:ENABLE_FILE_LOGGING}").unwrap(),
+            ),
+        ]);
 
-        let secrets = HashMap::from([(
-            Namespace::EnvironmentVariable.namespaced_name("REGISTRY_URL"),
-            Variable::new_final_string_variable("random-registry-url".to_string()),
-        )]);
+        let secrets = HashMap::from([
+            (
+                Namespace::EnvironmentVariable.namespaced_name("REGISTRY_URL"),
+                Variable::new_final_string_variable("test-registry-url".to_string()),
+            ),
+            (
+                Namespace::EnvironmentVariable.namespaced_name("ENABLE_FILE_LOGGING"),
+                Variable::from(serde_yaml::Value::Bool(true)),
+            ),
+        ]);
 
         let renderer =
             TemplateRenderer::default().with_agent_control_variables(HashMap::new().into_iter());
@@ -769,14 +802,15 @@ deployment:
             )
             .unwrap();
         assert_eq!(
-            rendered::Args(vec!("random-registry-url".to_string())),
-            extract_runtime_by_environment(runtime_config)
+            rendered::Args(vec!("test-registry-url/test-repository".to_string())),
+            extract_runtime_by_environment(runtime_config.clone())
                 .executables
                 .first()
                 .unwrap()
                 .args
                 .clone()
         );
+        assert!(extract_runtime_by_environment(runtime_config.clone()).enable_file_logging);
     }
 
     // Agent Type and Values definitions
diff --git a/agent-control/src/agent_type/variable.rs b/agent-control/src/agent_type/variable.rs
@@ -211,6 +211,7 @@ mod tests {
 
     #[test]
     fn variable_definition_tree_deserialize() {
+        use super::fields::DefaultValue;
         let value = r#"
 foo:
   bar:
@@ -235,7 +236,7 @@ foo:
                         variable_type: VariableTypeDefinition::String(StringFieldsDefinition {
                             inner: FieldsDefinition {
                                 required: false,
-                                default: Some("a".to_string()),
+                                default: Some(DefaultValue::Value("a".to_string())),
                             },
                             variants: VariantsConfig {
                                 ac_config_field: Some("foo.bar.var_name".to_string()),
diff --git a/agent-control/src/agent_type/variable/fields.rs b/agent-control/src/agent_type/variable/fields.rs
@@ -8,6 +8,7 @@ use crate::agent_type::{
     error::AgentTypeError,
     variable::{
         constraints::{VariableConstraints, VariantsConstraints},
+        namespace::Namespace,
         variants::{Variants, VariantsConfig},
     },
 };
@@ -19,7 +20,17 @@ where
     T: PartialEq,
 {
     pub(crate) required: bool,
-    pub(crate) default: Option<T>,
+    pub(crate) default: Option<DefaultValue<T>>,
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+#[serde(untagged)]
+pub enum DefaultValue<T>
+where
+    T: PartialEq,
+{
+    Value(T),
+    Template(String),
 }
 
 /// Type to support special default deserialization for 'null' Yaml value in 'default'.
@@ -47,7 +58,8 @@ where
     T: PartialEq,
 {
     pub(crate) required: bool,
-    pub(crate) default: Option<T>,
+    #[serde(flatten)]
+    pub(crate) default: Option<DefaultValue<T>>,
     pub(crate) final_value: Option<T>, // TODO: move this outside the struct and avoid mutating the variables
 }
 
@@ -133,7 +145,7 @@ impl StringFields {
 
 impl<'de, T> Deserialize<'de> for FieldsDefinition<T>
 where
-    T: Deserialize<'de> + PartialEq,
+    T: serde::de::DeserializeOwned + PartialEq,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -142,8 +154,8 @@ where
         use serde::de::Error;
         // intermediate serialization type to validate `default` and `required` fields
         #[derive(Debug, Deserialize)]
-        struct IntermediateValueKind<T: PartialEq> {
-            default: Option<T>,
+        struct IntermediateValueKind {
+            default: Option<serde_yaml::Value>,
             required: bool,
         }
 
@@ -162,12 +174,60 @@ where
         }
 
         Ok(FieldsDefinition {
-            default: intermediate_spec.default,
             required: intermediate_spec.required,
+            default: intermediate_spec
+                .default
+                .map(serde_yaml::from_value::<DefaultValue<T>>)
+                .transpose()
+                .map_err(|_| {
+                    D::Error::custom(AgentTypeError::Parse(
+                        "default value is not of the correct type".to_string(),
+                    ))
+                })?,
         })
     }
 }
 
+impl<T> DefaultValue<T>
+where
+    T: PartialEq,
+{
+    pub fn as_value(&self) -> Option<&T> {
+        match self {
+            DefaultValue::Value(v) => Some(v),
+            DefaultValue::Template(_) => None,
+        }
+    }
+}
+
+impl<'de, T> Deserialize<'de> for DefaultValue<T>
+where
+    T: serde::de::DeserializeOwned + PartialEq,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let yaml_val = serde_yaml::Value::deserialize(deserializer)?;
+
+        match serde_yaml::from_value::<T>(yaml_val.clone()) {
+            Ok(value) => Ok(DefaultValue::Value(value)),
+            Err(_) => {
+                if let serde_yaml::Value::String(s) = yaml_val
+                    && s.starts_with(format!("${{{}", Namespace::Default).as_str())
+                    && s.ends_with("}")
+                {
+                    Ok(DefaultValue::Template(s))
+                } else {
+                    Err(serde::de::Error::custom(
+                        "default value must be of the correct type or an `nr-default` template string",
+                    ))
+                }
+            }
+        }
+    }
+}
+
 // An special deserializer is used in order to consider the absence of default as a 'null' Yaml default value.
 impl<'de> Deserialize<'de> for YamlFieldsDefinition {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -198,7 +258,7 @@ impl<'de> Deserialize<'de> for YamlFieldsDefinition {
         Ok(YamlFieldsDefinition {
             inner: FieldsDefinition {
                 required: intermediate_spec.required,
-                default: intermediate_spec.default,
+                default: intermediate_spec.default.map(DefaultValue::Value),
             },
         })
     }
@@ -221,7 +281,7 @@ mod tests {
         },
     };
 
-    use super::Fields;
+    use super::{DefaultValue, Fields};
 
     impl<T> Fields<T>
     where
@@ -230,7 +290,7 @@ mod tests {
         pub(crate) fn new(required: bool, default: Option<T>, final_value: Option<T>) -> Self {
             Self {
                 required,
-                default,
+                default: default.map(DefaultValue::Value),
                 final_value,
             }
         }
@@ -246,7 +306,7 @@ mod tests {
             Self {
                 inner: Fields::<String> {
                     required,
-                    default,
+                    default: default.map(DefaultValue::Value),
                     final_value,
                 },
                 variants,
@@ -257,7 +317,10 @@ mod tests {
     impl YamlFieldsDefinition {
         pub(crate) fn new(required: bool, default: Option<serde_yaml::Value>) -> Self {
             Self {
-                inner: FieldsDefinition { required, default },
+                inner: FieldsDefinition {
+                    required,
+                    default: default.map(DefaultValue::Value),
+                },
             }
         }
     }
diff --git a/agent-control/src/agent_type/variable/variable_type.rs b/agent-control/src/agent_type/variable/variable_type.rs
