Move env var read to deserialization

Signed-off-by: Rob Geada <[email protected]>

Author: RobGeada

src/clients/http.rs

@@ -144,9 +144,7 @@ impl HttpClient {
 
     /// Injects the API token as a Bearer token in the Authorization header if configured and present in the environment.
     fn inject_api_token(&self, headers: &mut HeaderMap) -> Result<(), Error> {
-        if let Some(env_var) = &self.api_token
-            && let Ok(token) = std::env::var(env_var)
-        {
+        if let Some(token) = &self.api_token {
             headers.insert(
                 http::header::AUTHORIZATION,
                 HeaderValue::from_str(&format!("Bearer {}", token)).map_err(|e| Error::Http {

src/config.rs

@@ -23,7 +23,10 @@ use std::{
 use serde::Deserialize;
 use tracing::{debug, error, info, warn};
 
-use crate::clients::{chunker::DEFAULT_CHUNKER_ID, is_valid_hostname};
+use crate::{
+    clients::{chunker::DEFAULT_CHUNKER_ID, is_valid_hostname},
+    utils::from_env,
+};
 
 /// Default allowed headers to passthrough to clients.
 const DEFAULT_ALLOWED_HEADERS: &[&str] = &[];
@@ -87,6 +90,7 @@ pub struct ServiceConfig {
     /// Keep-alive timeout in seconds for client calls [currently only for grpc generation]
     pub keep_alive_timeout: Option<u64>,
     /// Name of environment variable that contains the API key to use for this service [currently only for http generation]
+    #[serde(default, deserialize_with = "from_env")]
     pub api_token: Option<String>,
 }
 

src/utils.rs

@@ -34,3 +34,56 @@ where
         OneOrMany::Many(values) => Ok(values),
     }
 }
+
+/// Serde helper to deserialize value from environment variable.
+pub fn from_env<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let env_name: Option<String> = Option::deserialize(deserializer)?;
+    if let Some(env_name) = env_name {
+        let value = std::env::var(&env_name)
+            .map_err(|_| serde::de::Error::custom(format!("env var `{env_name}` not found")))?;
+        Ok(Some(value))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde::Deserialize;
+    use serde_json::json;
+
+    use super::from_env;
+
+    #[derive(Debug, Deserialize)]
+    pub struct Config {
+        #[serde(default, deserialize_with = "from_env")]
+        pub api_token: Option<String>,
+    }
+
+    #[test]
+    fn test_from_env() -> Result<(), Box<dyn std::error::Error>> {
+        // Test no value
+        let config: Config = serde_json::from_value(json!({}))?;
+        assert_eq!(config.api_token, None);
+
+        // Test invalid value
+        let config: Result<Config, serde_json::error::Error> = serde_json::from_value(json!({
+            "api_token": "DOES_NOT_EXIST"
+        }));
+        assert!(config.is_err_and(|err| err.to_string() == "env var `DOES_NOT_EXIST` not found"));
+
+        // Test valid value
+        unsafe {
+            std::env::set_var("CLIENT_API_TOKEN", "token");
+        }
+        let config: Config = serde_json::from_value(json!({
+            "api_token": "CLIENT_API_TOKEN"
+        }))?;
+        assert_eq!(config.api_token, Some("token".into()));
+
+        Ok(())
+    }
+}