Headers file (#365)

Author: matthewmturner

src/args.rs

@@ -109,6 +109,12 @@ pub struct DftArgs {
     )]
     pub header: Option<Vec<(String, String)>>,
 
+    #[clap(
+        long,
+        help = "Path to file containing Flight SQL headers. Supports simple format ('Name: Value') and curl config format ('header = Name: Value' or '-H \"Name: Value\"'). Only used for FlightSQL"
+    )]
+    pub headers_file: Option<PathBuf>,
+
     #[clap(
         long,
         short,
@@ -257,7 +263,7 @@ fn parse_command(command: &str) -> std::result::Result<String, String> {
 fn parse_header_line(line: &str) -> Result<(String, String), String> {
     let (name, value) = line
         .split_once(':')
-        .ok_or_else(|| format!("Invalid header format: '{}'", line))?;
+        .ok_or_else(|| format!("Invalid header format: '{}'\n       Expected format: 'Header-Name: Header-Value', 'header = Name: Value', or '-H \"Name: Value\"'", line))?;
 
     let name =
         HeaderName::try_from(name.trim()).map_err(|e| format!("Invalid header name: {}", e))?;
@@ -270,3 +276,213 @@ fn parse_header_line(line: &str) -> Result<(String, String), String> {
 
     Ok((name.to_string(), value_str.to_string()))
 }
+
+/// Parse headers from a file supporting both simple and curl config formats
+///
+/// Supported formats:
+/// - Simple: `Header-Name: Header-Value`
+/// - Curl config: `header = Name: Value` or `-H "Name: Value"`
+/// - Comments: Lines starting with `#`
+/// - Blank lines are ignored
+///
+/// Both formats can be mixed in the same file.
+pub fn parse_headers_file(path: &Path) -> Result<Vec<(String, String)>, String> {
+    let content = std::fs::read_to_string(path)
+        .map_err(|e| format!("Failed to read headers file '{}': {}", path.display(), e))?;
+
+    let mut headers = Vec::new();
+    for (line_num, line) in content.lines().enumerate() {
+        let line = line.trim();
+
+        // Skip comments and blank lines
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        // Detect and parse format
+        let header_value = if let Some(stripped) = line.strip_prefix("header") {
+            // Curl config format: "header = Name: Value" or "header=Name: Value"
+            let stripped = stripped.trim_start();
+            if let Some(value) = stripped.strip_prefix('=') {
+                value.trim()
+            } else {
+                line // Not curl format, try simple format
+            }
+        } else if let Some(stripped) = line.strip_prefix("-H") {
+            // Curl config format: -H "Name: Value" or -H Name: Value
+            let stripped = stripped.trim();
+            // Remove surrounding quotes if present
+            stripped.trim_matches(|c| c == '"' || c == '\'')
+        } else {
+            // Simple format: "Name: Value"
+            line
+        };
+
+        // Parse header line
+        match parse_header_line(header_value) {
+            Ok(header) => headers.push(header),
+            Err(e) => {
+                return Err(format!(
+                    "Invalid header format at line {} in '{}': '{}'\n{}",
+                    line_num + 1,
+                    path.display(),
+                    line,
+                    e
+                ));
+            }
+        }
+    }
+
+    Ok(headers)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_parse_headers_file_simple_format() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "x-api-key: secret123").unwrap();
+        writeln!(file, "database: production").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[1],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_curl_format() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "header = x-api-key: secret123").unwrap();
+        writeln!(file, "-H \"database: production\"").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[1],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_mixed_format() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "# Simple format").unwrap();
+        writeln!(file, "x-test: value1").unwrap();
+        writeln!(file, "").unwrap();
+        writeln!(file, "# Curl config format").unwrap();
+        writeln!(file, "header = x-api-key: secret123").unwrap();
+        writeln!(file, "-H \"database: production\"").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 3);
+        assert_eq!(headers[0], ("x-test".to_string(), "value1".to_string()));
+        assert_eq!(
+            headers[1],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[2],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_with_comments() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "# This is a comment").unwrap();
+        writeln!(file, "x-api-key: secret123").unwrap();
+        writeln!(file, "# Another comment").unwrap();
+        writeln!(file, "database: production").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[1],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_blank_lines() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "x-api-key: secret123").unwrap();
+        writeln!(file, "").unwrap();
+        writeln!(file, "   ").unwrap();
+        writeln!(file, "database: production").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[1],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_curl_with_quotes() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "-H \"x-api-key: secret123\"").unwrap();
+        writeln!(file, "-H 'database: production'").unwrap();
+        file.flush().unwrap();
+
+        let headers = parse_headers_file(file.path()).unwrap();
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("x-api-key".to_string(), "secret123".to_string())
+        );
+        assert_eq!(
+            headers[1],
+            ("database".to_string(), "production".to_string())
+        );
+    }
+
+    #[test]
+    fn test_parse_headers_file_invalid_format() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "x-api-key: secret123").unwrap();
+        writeln!(file, "invalid-line-without-colon").unwrap();
+        file.flush().unwrap();
+
+        let result = parse_headers_file(file.path());
+        assert!(result.is_err());
+        assert!(result
+            .unwrap_err()
+            .contains("Invalid header format at line 2"));
+    }
+
+    #[test]
+    fn test_parse_headers_file_not_found() {
+        let result = parse_headers_file(Path::new("/nonexistent/file.txt"));
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Failed to read headers file"));
+    }
+}

src/cli/mod.rs

@@ -41,7 +41,7 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 #[cfg(feature = "flightsql")]
 use {
-    crate::args::{Command, FlightSqlCommand},
+    crate::args::{parse_headers_file, Command, FlightSqlCommand},
     datafusion_app::{
         config::{AuthConfig, FlightSQLConfig},
         flightsql::FlightSQLContext,
@@ -870,10 +870,41 @@ pub async fn try_run(cli: DftArgs, config: AppConfig) -> Result<()> {
                 config.flightsql_client.connection_url,
                 config.flightsql_client.benchmark_iterations,
                 auth,
-                config.flightsql_client.headers,
+                config.flightsql_client.headers.clone(),
             );
             let flightsql_ctx = FlightSQLContext::new(flightsql_cfg);
-            let headers = cli.header.clone().map(|vec| vec.into_iter().collect());
+
+            // Three-way header merge: config < file < CLI
+            let mut all_headers = config.flightsql_client.headers.clone();
+
+            // Merge headers from file (if specified in config or CLI)
+            let headers_file = cli
+                .headers_file
+                .as_ref()
+                .or(config.flightsql_client.headers_file.as_ref());
+
+            if let Some(file_path) = headers_file {
+                match parse_headers_file(file_path) {
+                    Ok(file_headers) => {
+                        all_headers.extend(file_headers);
+                    }
+                    Err(e) => {
+                        return Err(eyre!("Error reading headers file: {}", e));
+                    }
+                }
+            }
+
+            // Merge CLI headers (highest precedence)
+            if let Some(cli_headers) = &cli.header {
+                all_headers.extend(cli_headers.iter().cloned());
+            }
+
+            let headers = if all_headers.is_empty() {
+                None
+            } else {
+                Some(all_headers)
+            };
+
             flightsql_ctx
                 .create_client(cli.host.clone(), headers)
                 .await?;

src/config.rs

@@ -120,6 +120,8 @@ pub struct FlightSQLClientConfig {
     pub auth: AuthConfig,
     #[serde(default = "default_headers")]
     pub headers: HashMap<String, String>,
+    #[serde(default)]
+    pub headers_file: Option<PathBuf>,
 }
 
 #[cfg(feature = "flightsql")]
@@ -130,6 +132,7 @@ impl Default for FlightSQLClientConfig {
             benchmark_iterations: default_benchmark_iterations(),
             auth: default_auth_config(),
             headers: default_headers(),
+            headers_file: None,
         }
     }
 }

src/tui/mod.rs

@@ -389,14 +389,36 @@ pub async fn try_run(cli: DftArgs, config: AppConfig) -> Result<()> {
 
     #[cfg(feature = "flightsql")]
     {
+        use crate::args::parse_headers_file;
         use datafusion_app::config::FlightSQLConfig;
         use datafusion_app::flightsql::FlightSQLContext;
 
+        // Merge headers: config < file (CLI headers are merged later in the handler)
+        let mut all_headers = config.flightsql_client.headers.clone();
+
+        // Load headers from file if specified in config or CLI args
+        let headers_file = cli
+            .headers_file
+            .as_ref()
+            .or(config.flightsql_client.headers_file.as_ref());
+
+        if let Some(file_path) = headers_file {
+            match parse_headers_file(file_path) {
+                Ok(file_headers) => {
+                    all_headers.extend(file_headers);
+                }
+                Err(e) => {
+                    // TUI silently logs file errors to avoid disrupting UI
+                    error!("Error reading headers file: {}", e);
+                }
+            }
+        }
+
         let flightsql_config = FlightSQLConfig::new(
             config.flightsql_client.connection_url.clone(),
             config.flightsql_client.benchmark_iterations,
             config.flightsql_client.auth.clone(),
-            config.flightsql_client.headers.clone(),
+            all_headers,
         );
         app_execution.with_flightsql_ctx(FlightSQLContext::new(flightsql_config));
     }