kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg/src/core/server_config.rs

@@ -1,1220 +0,0 @@
-//! Server configuration for the Kreuzberg API.
-//!
-//! This module provides the `ServerConfig` struct for managing API server settings
-//! including host, port, CORS, and upload size limits. Configuration can be loaded
-//! from TOML, YAML, or JSON files and can be overridden by environment variables.
-//!
-//! # Features
-//!
-//! - **Multi-format support**: Load configuration from TOML, YAML, or JSON files
-//! - **Environment overrides**: All settings can be overridden via environment variables
-//! - **Backward compatibility**: Supports legacy `max_upload_mb` field for smooth migrations
-//! - **Sensible defaults**: All fields have reasonable defaults matching current behavior
-//! - **Flexible CORS**: Support for all origins (default) or specific origin lists
-//!
-//! # Example
-//!
-//! ```rust,no_run
-//! use kreuzberg::core::ServerConfig;
-//!
-//! # fn example() -> kreuzberg::Result<()> {
-//! // Create with defaults
-//! let mut config = ServerConfig::default();
-//!
-//! // Or load from file
-//! let mut config = ServerConfig::from_file("kreuzberg.toml")?;
-//!
-//! // Apply environment variable overrides
-//! config.apply_env_overrides()?;
-//!
-//! # Ok(())
-//! # }
-//! ```
-
-use crate::{KreuzbergError, Result};
-use serde::{Deserialize, Serialize};
-use std::path::Path;
-
-/// Default host address for API server
-const DEFAULT_HOST: &str = "127.0.0.1";
-
-/// Default port for API server
-const DEFAULT_PORT: u16 = 8000;
-
-/// Default maximum request body size: 100 MB
-const DEFAULT_MAX_REQUEST_BODY_BYTES: usize = 104_857_600;
-
-/// Default maximum multipart field size: 100 MB
-const DEFAULT_MAX_MULTIPART_FIELD_BYTES: usize = 104_857_600;
-
-/// API server configuration.
-///
-/// This struct holds all configuration options for the Kreuzberg API server,
-/// including host/port settings, CORS configuration, and upload limits.
-///
-/// # Defaults
-///
-/// - `host`: "127.0.0.1" (localhost only)
-/// - `port`: 8000
-/// - `cors_origins`: empty vector (allows all origins)
-/// - `max_request_body_bytes`: 104_857_600 (100 MB)
-/// - `max_multipart_field_bytes`: 104_857_600 (100 MB)
-/// - `max_upload_mb`: None (legacy field, not used if other fields set)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(default)]
-pub struct ServerConfig {
-    /// Server host address (e.g., "127.0.0.1", "0.0.0.0")
-    #[serde(default = "default_host")]
-    pub host: String,
-
-    /// Server port number
-    #[serde(default = "default_port")]
-    pub port: u16,
-
-    /// CORS allowed origins. Empty vector means allow all origins.
-    ///
-    /// If this is an empty vector, the server will accept requests from any origin.
-    /// If populated with specific origins (e.g., ["https://example.com"]), only
-    /// those origins will be allowed.
-    #[serde(default)]
-    pub cors_origins: Vec<String>,
-
-    /// Maximum size of request body in bytes (default: 100 MB)
-    #[serde(default = "default_max_request_body_bytes")]
-    pub max_request_body_bytes: usize,
-
-    /// Maximum size of multipart fields in bytes (default: 100 MB)
-    #[serde(default = "default_max_multipart_field_bytes")]
-    pub max_multipart_field_bytes: usize,
-
-    /// Legacy upload size limit in MB (for backward compatibility).
-    ///
-    /// This field is deprecated and only used for backward compatibility.
-    /// If set, it will override `max_multipart_field_bytes` during normalization.
-    /// New configurations should use `max_multipart_field_bytes` directly.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_upload_mb: Option<usize>,
-}
-
-impl Default for ServerConfig {
-    fn default() -> Self {
-        Self {
-            host: default_host(),
-            port: default_port(),
-            cors_origins: Vec::new(),
-            max_request_body_bytes: default_max_request_body_bytes(),
-            max_multipart_field_bytes: default_max_multipart_field_bytes(),
-            max_upload_mb: None,
-        }
-    }
-}
-
-// Default value functions for serde
-fn default_host() -> String {
-    DEFAULT_HOST.to_string()
-}
-
-fn default_port() -> u16 {
-    DEFAULT_PORT
-}
-
-fn default_max_request_body_bytes() -> usize {
-    DEFAULT_MAX_REQUEST_BODY_BYTES
-}
-
-fn default_max_multipart_field_bytes() -> usize {
-    DEFAULT_MAX_MULTIPART_FIELD_BYTES
-}
-
-impl ServerConfig {
-    /// Create a new `ServerConfig` with default values.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Get the server listen address (host:port).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// let config = ServerConfig::default();
-    /// assert_eq!(config.listen_addr(), "127.0.0.1:8000");
-    /// ```
-    pub fn listen_addr(&self) -> String {
-        format!("{}:{}", self.host, self.port)
-    }
-
-    /// Check if CORS allows all origins.
-    ///
-    /// Returns `true` if the `cors_origins` vector is empty, meaning all origins
-    /// are allowed. Returns `false` if specific origins are configured.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// let mut config = ServerConfig::default();
-    /// assert!(config.cors_allows_all());
-    ///
-    /// config.cors_origins.push("https://example.com".to_string());
-    /// assert!(!config.cors_allows_all());
-    /// ```
-    pub fn cors_allows_all(&self) -> bool {
-        self.cors_origins.is_empty()
-    }
-
-    /// Check if a given origin is allowed by CORS configuration.
-    ///
-    /// Returns `true` if:
-    /// - CORS allows all origins (empty origins list), or
-    /// - The given origin is in the allowed origins list
-    ///
-    /// # Arguments
-    ///
-    /// * `origin` - The origin to check (e.g., "https://example.com")
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// let mut config = ServerConfig::default();
-    /// assert!(config.is_origin_allowed("https://example.com"));
-    ///
-    /// config.cors_origins.push("https://allowed.com".to_string());
-    /// assert!(config.is_origin_allowed("https://allowed.com"));
-    /// assert!(!config.is_origin_allowed("https://denied.com"));
-    /// ```
-    pub fn is_origin_allowed(&self, origin: &str) -> bool {
-        self.cors_origins.is_empty() || self.cors_origins.contains(&origin.to_string())
-    }
-
-    /// Get maximum request body size in megabytes (rounded up).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// let mut config = ServerConfig::default();
-    /// assert_eq!(config.max_request_body_mb(), 100);
-    /// ```
-    pub fn max_request_body_mb(&self) -> usize {
-        self.max_request_body_bytes.div_ceil(1_048_576)
-    }
-
-    /// Get maximum multipart field size in megabytes (rounded up).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// let mut config = ServerConfig::default();
-    /// assert_eq!(config.max_multipart_field_mb(), 100);
-    /// ```
-    pub fn max_multipart_field_mb(&self) -> usize {
-        self.max_multipart_field_bytes.div_ceil(1_048_576)
-    }
-
-    /// Normalize legacy field values for backward compatibility.
-    ///
-    /// If `max_upload_mb` is set, it will be converted to bytes and used to
-    /// override `max_multipart_field_bytes`. This allows old configurations
-    /// using the legacy field to continue working.
-    ///
-    /// This method is automatically called by `apply_env_overrides()`.
-    pub fn normalize_legacy_fields(&mut self) {
-        if let Some(max_upload_mb) = self.max_upload_mb {
-            // Convert MB to bytes
-            let max_bytes = max_upload_mb.saturating_mul(1_048_576);
-            self.max_multipart_field_bytes = max_bytes;
-        }
-    }
-
-    /// Apply environment variable overrides to the configuration.
-    ///
-    /// Reads the following environment variables and overrides config values if set:
-    ///
-    /// - `KREUZBERG_HOST` - Server host address
-    /// - `KREUZBERG_PORT` - Server port number (parsed as u16)
-    /// - `KREUZBERG_CORS_ORIGINS` - Comma-separated list of allowed origins
-    /// - `KREUZBERG_MAX_REQUEST_BODY_BYTES` - Max request body size in bytes
-    /// - `KREUZBERG_MAX_MULTIPART_FIELD_BYTES` - Max multipart field size in bytes
-    /// - `KREUZBERG_MAX_UPLOAD_SIZE_MB` - Max upload size in MB (legacy)
-    ///
-    /// # Errors
-    ///
-    /// Returns `KreuzbergError::Validation` if:
-    /// - `KREUZBERG_PORT` cannot be parsed as u16
-    /// - `KREUZBERG_MAX_REQUEST_BODY_BYTES` cannot be parsed as usize
-    /// - `KREUZBERG_MAX_MULTIPART_FIELD_BYTES` cannot be parsed as usize
-    /// - `KREUZBERG_MAX_UPLOAD_SIZE_MB` cannot be parsed as usize
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// # fn example() -> kreuzberg::Result<()> {
-    /// std::env::set_var("KREUZBERG_HOST", "0.0.0.0");
-    /// std::env::set_var("KREUZBERG_PORT", "3000");
-    ///
-    /// let mut config = ServerConfig::default();
-    /// config.apply_env_overrides()?;
-    ///
-    /// assert_eq!(config.host, "0.0.0.0");
-    /// assert_eq!(config.port, 3000);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn apply_env_overrides(&mut self) -> Result<()> {
-        // Host override
-        if let Ok(host) = std::env::var("KREUZBERG_HOST") {
-            self.host = host;
-        }
-
-        // Port override
-        if let Ok(port_str) = std::env::var("KREUZBERG_PORT") {
-            self.port = port_str.parse::<u16>().map_err(|e| {
-                KreuzbergError::validation(format!(
-                    "KREUZBERG_PORT must be a valid u16 number, got '{}': {}",
-                    port_str, e
-                ))
-            })?;
-        }
-
-        // CORS origins override (comma-separated)
-        if let Ok(origins_str) = std::env::var("KREUZBERG_CORS_ORIGINS") {
-            self.cors_origins = origins_str
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-        }
-
-        // Max request body bytes override
-        if let Ok(bytes_str) = std::env::var("KREUZBERG_MAX_REQUEST_BODY_BYTES") {
-            self.max_request_body_bytes = bytes_str.parse::<usize>().map_err(|e| {
-                KreuzbergError::validation(format!(
-                    "KREUZBERG_MAX_REQUEST_BODY_BYTES must be a valid usize, got '{}': {}",
-                    bytes_str, e
-                ))
-            })?;
-        }
-
-        // Max multipart field bytes override
-        if let Ok(bytes_str) = std::env::var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES") {
-            self.max_multipart_field_bytes = bytes_str.parse::<usize>().map_err(|e| {
-                KreuzbergError::validation(format!(
-                    "KREUZBERG_MAX_MULTIPART_FIELD_BYTES must be a valid usize, got '{}': {}",
-                    bytes_str, e
-                ))
-            })?;
-        }
-
-        // Legacy max upload size override (in MB)
-        if let Ok(mb_str) = std::env::var("KREUZBERG_MAX_UPLOAD_SIZE_MB") {
-            let mb = mb_str.parse::<usize>().map_err(|e| {
-                KreuzbergError::validation(format!(
-                    "KREUZBERG_MAX_UPLOAD_SIZE_MB must be a valid usize, got '{}': {}",
-                    mb_str, e
-                ))
-            })?;
-            self.max_upload_mb = Some(mb);
-        }
-
-        // Apply legacy field normalization
-        self.normalize_legacy_fields();
-
-        Ok(())
-    }
-
-    /// Load server configuration from a file.
-    ///
-    /// Automatically detects the file format based on extension:
-    /// - `.toml` - TOML format
-    /// - `.yaml` or `.yml` - YAML format
-    /// - `.json` - JSON format
-    ///
-    /// This function handles two config file formats:
-    /// 1. Flat format: Server config at root level
-    /// 2. Nested format: Server config under `[server]` section (combined with ExtractionConfig)
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Path to the configuration file
-    ///
-    /// # Errors
-    ///
-    /// Returns `KreuzbergError::Validation` if:
-    /// - File doesn't exist or cannot be read
-    /// - File extension is not recognized
-    /// - File content is invalid for the detected format
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// # fn example() -> kreuzberg::Result<()> {
-    /// let config = ServerConfig::from_file("kreuzberg.toml")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn from_file(path: impl AsRef<Path>) -> Result<Self> {
-        let path = path.as_ref();
-
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| KreuzbergError::validation(format!("Failed to read config file {}: {}", path.display(), e)))?;
-
-        let extension = path.extension().and_then(|ext| ext.to_str()).ok_or_else(|| {
-            KreuzbergError::validation(format!(
-                "Cannot determine file format: no extension found in {}",
-                path.display()
-            ))
-        })?;
-
-        let mut config = match extension.to_lowercase().as_str() {
-            "toml" => {
-                // Try nested format first (with [server] section)
-                #[derive(Deserialize)]
-                struct RootConfig {
-                    #[serde(default)]
-                    server: Option<ServerConfig>,
-                }
-
-                if let Ok(root) = toml::from_str::<RootConfig>(&content) {
-                    if let Some(server) = root.server {
-                        server
-                    } else {
-                        // No [server] section, try flat format
-                        toml::from_str::<Self>(&content).map_err(|e| {
-                            KreuzbergError::validation(format!("Invalid TOML in {}: {}", path.display(), e))
-                        })?
-                    }
-                } else {
-                    // Fall back to flat format
-                    toml::from_str::<Self>(&content)
-                        .map_err(|e| KreuzbergError::validation(format!("Invalid TOML in {}: {}", path.display(), e)))?
-                }
-            }
-            "yaml" | "yml" => {
-                // Try nested format first (with server: section)
-                #[derive(Deserialize)]
-                struct RootConfig {
-                    #[serde(default)]
-                    server: Option<ServerConfig>,
-                }
-
-                if let Ok(root) = serde_yaml_ng::from_str::<RootConfig>(&content) {
-                    if let Some(server) = root.server {
-                        server
-                    } else {
-                        // No server section, try flat format
-                        serde_yaml_ng::from_str::<Self>(&content).map_err(|e| {
-                            KreuzbergError::validation(format!("Invalid YAML in {}: {}", path.display(), e))
-                        })?
-                    }
-                } else {
-                    // Fall back to flat format
-                    serde_yaml_ng::from_str::<Self>(&content)
-                        .map_err(|e| KreuzbergError::validation(format!("Invalid YAML in {}: {}", path.display(), e)))?
-                }
-            }
-            "json" => {
-                // Try nested format first (with "server" key)
-                #[derive(Deserialize)]
-                struct RootConfig {
-                    #[serde(default)]
-                    server: Option<ServerConfig>,
-                }
-
-                if let Ok(root) = serde_json::from_str::<RootConfig>(&content) {
-                    if let Some(server) = root.server {
-                        server
-                    } else {
-                        // No server key, try flat format
-                        serde_json::from_str::<Self>(&content).map_err(|e| {
-                            KreuzbergError::validation(format!("Invalid JSON in {}: {}", path.display(), e))
-                        })?
-                    }
-                } else {
-                    // Fall back to flat format
-                    serde_json::from_str::<Self>(&content)
-                        .map_err(|e| KreuzbergError::validation(format!("Invalid JSON in {}: {}", path.display(), e)))?
-                }
-            }
-            _ => {
-                return Err(KreuzbergError::validation(format!(
-                    "Unsupported config file format: .{}. Supported formats: .toml, .yaml, .yml, .json",
-                    extension
-                )));
-            }
-        };
-
-        // Normalize legacy fields
-        config.normalize_legacy_fields();
-
-        Ok(config)
-    }
-
-    /// Load server configuration from a TOML file.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Path to the TOML file
-    ///
-    /// # Errors
-    ///
-    /// Returns `KreuzbergError::Validation` if the file doesn't exist or is invalid TOML.
-    ///
-    /// # Example
-    ///
-    /// ```rust,no_run
-    /// use kreuzberg::core::ServerConfig;
-    ///
-    /// # fn example() -> kreuzberg::Result<()> {
-    /// let config = ServerConfig::from_toml_file("kreuzberg.toml")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn from_toml_file(path: impl AsRef<Path>) -> Result<Self> {
-        let path = path.as_ref();
-
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| KreuzbergError::validation(format!("Failed to read config file {}: {}", path.display(), e)))?;
-
-        let mut config: Self = toml::from_str(&content)
-            .map_err(|e| KreuzbergError::validation(format!("Invalid TOML in {}: {}", path.display(), e)))?;
-
-        config.normalize_legacy_fields();
-
-        Ok(config)
-    }
-
-    /// Load server configuration from a YAML file.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Path to the YAML file
-    ///
-    /// # Errors
-    ///
-    /// Returns `KreuzbergError::Validation` if the file doesn't exist or is invalid YAML.
-    pub fn from_yaml_file(path: impl AsRef<Path>) -> Result<Self> {
-        let path = path.as_ref();
-
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| KreuzbergError::validation(format!("Failed to read config file {}: {}", path.display(), e)))?;
-
-        let mut config: Self = serde_yaml_ng::from_str(&content)
-            .map_err(|e| KreuzbergError::validation(format!("Invalid YAML in {}: {}", path.display(), e)))?;
-
-        config.normalize_legacy_fields();
-
-        Ok(config)
-    }
-
-    /// Load server configuration from a JSON file.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Path to the JSON file
-    ///
-    /// # Errors
-    ///
-    /// Returns `KreuzbergError::Validation` if the file doesn't exist or is invalid JSON.
-    pub fn from_json_file(path: impl AsRef<Path>) -> Result<Self> {
-        let path = path.as_ref();
-
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| KreuzbergError::validation(format!("Failed to read config file {}: {}", path.display(), e)))?;
-
-        let mut config: Self = serde_json::from_str(&content)
-            .map_err(|e| KreuzbergError::validation(format!("Invalid JSON in {}: {}", path.display(), e)))?;
-
-        config.normalize_legacy_fields();
-
-        Ok(config)
-    }
-}
-
-#[cfg(test)]
-#[allow(unsafe_code)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[test]
-    fn test_default_config() {
-        let config = ServerConfig::default();
-        assert_eq!(config.host, "127.0.0.1");
-        assert_eq!(config.port, 8000);
-        assert!(config.cors_origins.is_empty());
-        assert_eq!(config.max_request_body_bytes, 104_857_600);
-        assert_eq!(config.max_multipart_field_bytes, 104_857_600);
-        assert!(config.max_upload_mb.is_none());
-    }
-
-    #[test]
-    fn test_listen_addr() {
-        let config = ServerConfig::default();
-        assert_eq!(config.listen_addr(), "127.0.0.1:8000");
-    }
-
-    #[test]
-    fn test_listen_addr_custom() {
-        let config = ServerConfig {
-            host: "0.0.0.0".to_string(),
-            port: 3000,
-            ..Default::default()
-        };
-        assert_eq!(config.listen_addr(), "0.0.0.0:3000");
-    }
-
-    #[test]
-    fn test_cors_allows_all() {
-        let mut config = ServerConfig::default();
-        assert!(config.cors_allows_all());
-
-        config.cors_origins.push("https://example.com".to_string());
-        assert!(!config.cors_allows_all());
-    }
-
-    #[test]
-    fn test_is_origin_allowed_all() {
-        let config = ServerConfig::default();
-        assert!(config.is_origin_allowed("https://example.com"));
-        assert!(config.is_origin_allowed("https://other.com"));
-    }
-
-    #[test]
-    fn test_is_origin_allowed_specific() {
-        let mut config = ServerConfig::default();
-        config.cors_origins.push("https://allowed.com".to_string());
-
-        assert!(config.is_origin_allowed("https://allowed.com"));
-        assert!(!config.is_origin_allowed("https://denied.com"));
-    }
-
-    #[test]
-    fn test_max_request_body_mb() {
-        let config = ServerConfig::default();
-        assert_eq!(config.max_request_body_mb(), 100);
-    }
-
-    #[test]
-    fn test_max_multipart_field_mb() {
-        let config = ServerConfig::default();
-        assert_eq!(config.max_multipart_field_mb(), 100);
-    }
-
-    #[test]
-    fn test_max_bytes_to_mb_rounding() {
-        let mut config = ServerConfig {
-            max_request_body_bytes: 1_048_576, // 1 MB
-            ..Default::default()
-        };
-        assert_eq!(config.max_request_body_mb(), 1);
-
-        config.max_request_body_bytes = 1_048_577; // 1 MB + 1 byte
-        assert_eq!(config.max_request_body_mb(), 2); // Rounds up
-    }
-
-    #[test]
-    fn test_normalize_legacy_max_upload_mb() {
-        let mut config = ServerConfig {
-            max_upload_mb: Some(50),
-            ..Default::default()
-        };
-
-        config.normalize_legacy_fields();
-
-        assert_eq!(config.max_multipart_field_bytes, 50 * 1_048_576);
-    }
-
-    #[test]
-    fn test_normalize_legacy_max_upload_mb_zero() {
-        let mut config = ServerConfig {
-            max_upload_mb: Some(0),
-            ..Default::default()
-        };
-
-        config.normalize_legacy_fields();
-
-        assert_eq!(config.max_multipart_field_bytes, 0);
-    }
-
-    #[test]
-    fn test_from_toml_file() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        fs::write(
-            &config_path,
-            r#"
-host = "0.0.0.0"
-port = 3000
-cors_origins = ["https://example.com", "https://other.com"]
-max_request_body_bytes = 50000000
-max_multipart_field_bytes = 75000000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_toml_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-        assert_eq!(config.cors_origins.len(), 2);
-        assert_eq!(config.max_request_body_bytes, 50_000_000);
-        assert_eq!(config.max_multipart_field_bytes, 75_000_000);
-    }
-
-    #[test]
-    fn test_from_yaml_file() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.yaml");
-
-        fs::write(
-            &config_path,
-            r#"
-host: 0.0.0.0
-port: 3000
-cors_origins:
-  - https://example.com
-  - https://other.com
-max_request_body_bytes: 50000000
-max_multipart_field_bytes: 75000000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_yaml_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-        assert_eq!(config.cors_origins.len(), 2);
-        assert_eq!(config.max_request_body_bytes, 50_000_000);
-        assert_eq!(config.max_multipart_field_bytes, 75_000_000);
-    }
-
-    #[test]
-    fn test_from_json_file() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.json");
-
-        fs::write(
-            &config_path,
-            r#"{
-  "host": "0.0.0.0",
-  "port": 3000,
-  "cors_origins": ["https://example.com", "https://other.com"],
-  "max_request_body_bytes": 50000000,
-  "max_multipart_field_bytes": 75000000
-}
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_json_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-        assert_eq!(config.cors_origins.len(), 2);
-        assert_eq!(config.max_request_body_bytes, 50_000_000);
-        assert_eq!(config.max_multipart_field_bytes, 75_000_000);
-    }
-
-    #[test]
-    fn test_from_file_auto_detects_toml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        fs::write(
-            &config_path,
-            r#"
-host = "0.0.0.0"
-port = 3000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-    }
-
-    #[test]
-    fn test_from_file_auto_detects_yaml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.yaml");
-
-        fs::write(
-            &config_path,
-            r#"
-host: 0.0.0.0
-port: 3000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-    }
-
-    #[test]
-    fn test_from_file_auto_detects_json() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.json");
-
-        fs::write(&config_path, r#"{"host": "0.0.0.0", "port": 3000}"#).unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-    }
-
-    #[test]
-    fn test_from_file_unsupported_extension() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.txt");
-
-        fs::write(&config_path, "host = 0.0.0.0").unwrap();
-
-        let result = ServerConfig::from_file(&config_path);
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("Unsupported config file format")
-        );
-    }
-
-    #[test]
-    fn test_from_file_no_extension() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server");
-
-        fs::write(&config_path, "host = 0.0.0.0").unwrap();
-
-        let result = ServerConfig::from_file(&config_path);
-        assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("no extension found"));
-    }
-
-    #[test]
-    fn test_legacy_max_upload_mb_in_file() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        fs::write(
-            &config_path,
-            r#"
-host = "127.0.0.1"
-port = 8000
-max_upload_mb = 50
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_toml_file(&config_path).unwrap();
-        assert_eq!(config.max_upload_mb, Some(50));
-        assert_eq!(config.max_multipart_field_bytes, 50 * 1_048_576);
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_host_override() {
-        let original = std::env::var("KREUZBERG_HOST").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_HOST", "192.168.1.1");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.host, "192.168.1.1");
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_HOST", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_HOST");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_port_override() {
-        let original = std::env::var("KREUZBERG_PORT").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_PORT", "5000");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.port, 5000);
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_PORT", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_PORT");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_port_invalid() {
-        let original = std::env::var("KREUZBERG_PORT").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_PORT", "not_a_number");
-        }
-
-        let mut config = ServerConfig::default();
-        let result = config.apply_env_overrides();
-
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("KREUZBERG_PORT must be a valid u16")
-        );
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_PORT", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_PORT");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_cors_origins_override() {
-        let original = std::env::var("KREUZBERG_CORS_ORIGINS").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_CORS_ORIGINS", "https://example.com, https://other.com");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.cors_origins.len(), 2);
-        assert!(config.cors_origins.contains(&"https://example.com".to_string()));
-        assert!(config.cors_origins.contains(&"https://other.com".to_string()));
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_CORS_ORIGINS", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_CORS_ORIGINS");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_max_request_body_bytes_override() {
-        let original = std::env::var("KREUZBERG_MAX_REQUEST_BODY_BYTES").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_MAX_REQUEST_BODY_BYTES", "52428800");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.max_request_body_bytes, 52_428_800);
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_MAX_REQUEST_BODY_BYTES", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_MAX_REQUEST_BODY_BYTES");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_max_multipart_field_bytes_override() {
-        let original = std::env::var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES", "78643200");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.max_multipart_field_bytes, 78_643_200);
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_legacy_max_upload_size_mb_override() {
-        let original = std::env::var("KREUZBERG_MAX_UPLOAD_SIZE_MB").ok();
-        unsafe {
-            std::env::set_var("KREUZBERG_MAX_UPLOAD_SIZE_MB", "75");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.max_upload_mb, Some(75));
-        assert_eq!(config.max_multipart_field_bytes, 75 * 1_048_576);
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = original {
-                std::env::set_var("KREUZBERG_MAX_UPLOAD_SIZE_MB", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_MAX_UPLOAD_SIZE_MB");
-            }
-        }
-    }
-
-    #[serial_test::serial]
-    #[test]
-    fn test_apply_env_multiple_overrides() {
-        let host_orig = std::env::var("KREUZBERG_HOST").ok();
-        let port_orig = std::env::var("KREUZBERG_PORT").ok();
-        let cors_orig = std::env::var("KREUZBERG_CORS_ORIGINS").ok();
-
-        unsafe {
-            std::env::set_var("KREUZBERG_HOST", "0.0.0.0");
-            std::env::set_var("KREUZBERG_PORT", "4000");
-            std::env::set_var("KREUZBERG_CORS_ORIGINS", "https://api.example.com");
-        }
-
-        let mut config = ServerConfig::default();
-        config.apply_env_overrides().unwrap();
-
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 4000);
-        assert_eq!(config.cors_origins.len(), 1);
-        assert_eq!(config.cors_origins[0], "https://api.example.com");
-
-        // Cleanup
-        unsafe {
-            if let Some(orig) = host_orig {
-                std::env::set_var("KREUZBERG_HOST", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_HOST");
-            }
-            if let Some(orig) = port_orig {
-                std::env::set_var("KREUZBERG_PORT", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_PORT");
-            }
-            if let Some(orig) = cors_orig {
-                std::env::set_var("KREUZBERG_CORS_ORIGINS", orig);
-            } else {
-                std::env::remove_var("KREUZBERG_CORS_ORIGINS");
-            }
-        }
-    }
-
-    #[test]
-    fn test_serde_default_serialization() {
-        let config = ServerConfig::default();
-        let json = serde_json::to_string(&config).unwrap();
-
-        // Should serialize without the max_upload_mb field when None
-        assert!(!json.contains("max_upload_mb"));
-    }
-
-    #[test]
-    fn test_serde_with_max_upload_mb_serialization() {
-        let config = ServerConfig {
-            max_upload_mb: Some(50),
-            ..Default::default()
-        };
-        let json = serde_json::to_string(&config).unwrap();
-
-        // Should serialize with max_upload_mb when Some
-        assert!(json.contains("max_upload_mb"));
-    }
-
-    #[test]
-    fn test_cors_origins_empty_in_toml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        fs::write(
-            &config_path,
-            r#"
-host = "127.0.0.1"
-port = 8000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_toml_file(&config_path).unwrap();
-        assert!(config.cors_origins.is_empty());
-        assert!(config.cors_allows_all());
-    }
-
-    #[test]
-    fn test_full_configuration_toml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        fs::write(
-            &config_path,
-            r#"
-host = "192.168.1.100"
-port = 9000
-cors_origins = ["https://app1.com", "https://app2.com", "https://app3.com"]
-max_request_body_bytes = 200000000
-max_multipart_field_bytes = 150000000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_toml_file(&config_path).unwrap();
-        assert_eq!(config.host, "192.168.1.100");
-        assert_eq!(config.port, 9000);
-        assert_eq!(config.listen_addr(), "192.168.1.100:9000");
-        assert_eq!(config.cors_origins.len(), 3);
-        assert!(!config.cors_allows_all());
-        assert!(config.is_origin_allowed("https://app1.com"));
-        assert!(!config.is_origin_allowed("https://app4.com"));
-        assert_eq!(config.max_request_body_bytes, 200_000_000);
-        assert_eq!(config.max_multipart_field_bytes, 150_000_000);
-        assert_eq!(config.max_request_body_mb(), 191);
-        assert_eq!(config.max_multipart_field_mb(), 144);
-    }
-
-    #[test]
-    fn test_from_file_with_nested_server_section_toml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("kreuzberg.toml");
-
-        // Config file with [server] section and other sections (like ExtractionConfig)
-        fs::write(
-            &config_path,
-            r#"
-[server]
-host = "0.0.0.0"
-port = 3000
-cors_origins = ["https://example.com"]
-
-[ocr]
-backend = "tesseract"
-language = "eng"
-
-[extraction]
-enabled = true
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 3000);
-        assert_eq!(config.cors_origins.len(), 1);
-        assert_eq!(config.cors_origins[0], "https://example.com");
-    }
-
-    #[test]
-    fn test_from_file_with_nested_server_section_yaml() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("kreuzberg.yaml");
-
-        // Config file with server: section and other sections
-        fs::write(
-            &config_path,
-            r#"
-server:
-  host: 0.0.0.0
-  port: 4000
-  cors_origins:
-    - https://example.com
-
-ocr:
-  backend: tesseract
-  language: eng
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 4000);
-        assert_eq!(config.cors_origins.len(), 1);
-    }
-
-    #[test]
-    fn test_from_file_with_nested_server_section_json() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("kreuzberg.json");
-
-        // Config file with "server" key and other sections
-        fs::write(
-            &config_path,
-            r#"
-{
-  "server": {
-    "host": "0.0.0.0",
-    "port": 5000,
-    "cors_origins": ["https://example.com"]
-  },
-  "ocr": {
-    "backend": "tesseract",
-    "language": "eng"
-  }
-}
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "0.0.0.0");
-        assert_eq!(config.port, 5000);
-        assert_eq!(config.cors_origins.len(), 1);
-    }
-
-    #[test]
-    fn test_from_file_flat_format_still_works() {
-        let dir = tempdir().unwrap();
-        let config_path = dir.path().join("server.toml");
-
-        // Old flat format without [server] section
-        fs::write(
-            &config_path,
-            r#"
-host = "192.168.1.1"
-port = 6000
-        "#,
-        )
-        .unwrap();
-
-        let config = ServerConfig::from_file(&config_path).unwrap();
-        assert_eq!(config.host, "192.168.1.1");
-        assert_eq!(config.port, 6000);
-    }
-}