subx_cli/config/
field_validator.rs

1//! Key-value validation for configuration service.
2//!
3//! This module handles the validation logic that was previously embedded
4//! in `ProductionConfigService::validate_and_set_value`. It provides
5//! field-specific validation for configuration keys and values.
6//!
7//! # Architecture
8//!
9//! - [`crate::config::validation`] - Low-level validation functions for individual values
10//! - [`crate::config::validator`] - High-level configuration section validators  
11//! - [`crate::config::field_validator`] (this module) - Key-value validation for configuration service
12
13use super::validation::*;
14use crate::{Result, error::SubXError};
15
16/// Validate and parse a configuration field based on its key.
17///
18/// This function handles the validation logic that was previously
19/// embedded in ProductionConfigService::validate_and_set_value.
20///
21/// # Arguments
22/// * `key` - The configuration key (e.g., "ai.temperature")
23/// * `value` - The string value to validate and parse
24///
25/// # Returns
26/// Returns Ok(()) if validation passes, or an error describing the validation failure.
27pub fn validate_field(key: &str, value: &str) -> Result<()> {
28    match key {
29        // AI configuration fields
30        "ai.provider" => {
31            validate_non_empty_string(value, "AI provider")?;
32            validate_enum(
33                value,
34                &["openai", "anthropic", "local", "openrouter", "azure-openai"],
35            )?;
36        }
37        "ai.model" => validate_ai_model(value)?,
38        "ai.api_key" => {
39            if !value.is_empty() {
40                validate_api_key(value)?;
41            }
42        }
43        "ai.base_url" => validate_url_format(value)?,
44        "ai.temperature" => {
45            let temp: f32 = value
46                .parse()
47                .map_err(|_| SubXError::config("Temperature must be a number"))?;
48            validate_temperature(temp)?;
49        }
50        "ai.max_tokens" => {
51            let tokens: u32 = value
52                .parse()
53                .map_err(|_| SubXError::config("Max tokens must be a positive integer"))?;
54            validate_positive_number(tokens as f64)?;
55        }
56        "ai.max_sample_length" => {
57            let length: usize = value
58                .parse()
59                .map_err(|_| SubXError::config("Max sample length must be a positive integer"))?;
60            validate_range(length, 100, 10000)?;
61        }
62        "ai.retry_attempts" => {
63            let attempts: u32 = value
64                .parse()
65                .map_err(|_| SubXError::config("Retry attempts must be a positive integer"))?;
66            validate_range(attempts, 1, 10)?;
67        }
68        "ai.retry_delay_ms" => {
69            let delay: u64 = value
70                .parse()
71                .map_err(|_| SubXError::config("Retry delay must be a positive integer"))?;
72            validate_range(delay, 100, 30000)?;
73        }
74        "ai.request_timeout_seconds" => {
75            let timeout: u64 = value
76                .parse()
77                .map_err(|_| SubXError::config("Request timeout must be a positive integer"))?;
78            validate_range(timeout, 10, 600)?;
79        }
80
81        // Azure OpenAI specific fields
82        "ai.api_version" => {
83            validate_non_empty_string(value, "Azure OpenAI API version")?;
84        }
85
86        // Sync configuration fields
87        "sync.default_method" => {
88            validate_enum(value, &["auto", "vad", "manual"])?;
89        }
90        "sync.max_offset_seconds" => {
91            let offset: f32 = value
92                .parse()
93                .map_err(|_| SubXError::config("Max offset must be a number"))?;
94            validate_range(offset, 0.1, 3600.0)?;
95        }
96        "sync.vad.enabled" => {
97            parse_bool(value)?;
98        }
99        "sync.vad.sensitivity" => {
100            let sensitivity: f32 = value
101                .parse()
102                .map_err(|_| SubXError::config("VAD sensitivity must be a number"))?;
103            validate_range(sensitivity, 0.0, 1.0)?;
104        }
105        "sync.vad.padding_chunks" => {
106            let chunks: u32 = value
107                .parse()
108                .map_err(|_| SubXError::config("Padding chunks must be a non-negative integer"))?;
109            validate_range(chunks, 0, 10)?;
110        }
111        "sync.vad.min_speech_duration_ms" => {
112            let _duration: u32 = value.parse().map_err(|_| {
113                SubXError::config("Min speech duration must be a non-negative integer")
114            })?;
115            // Non-negative validation is implicit in u32 parsing
116        }
117
118        // Formats configuration fields
119        "formats.default_output" => {
120            validate_enum(value, &["srt", "ass", "vtt", "webvtt"])?;
121        }
122        "formats.preserve_styling" => {
123            parse_bool(value)?;
124        }
125        "formats.default_encoding" => {
126            validate_enum(value, &["utf-8", "gbk", "big5", "shift_jis"])?;
127        }
128        "formats.encoding_detection_confidence" => {
129            let confidence: f32 = value
130                .parse()
131                .map_err(|_| SubXError::config("Encoding detection confidence must be a number"))?;
132            validate_range(confidence, 0.0, 1.0)?;
133        }
134
135        // General configuration fields
136        "general.backup_enabled" => {
137            parse_bool(value)?;
138        }
139        "general.max_concurrent_jobs" => {
140            let jobs: usize = value
141                .parse()
142                .map_err(|_| SubXError::config("Max concurrent jobs must be a positive integer"))?;
143            validate_range(jobs, 1, 64)?;
144        }
145        "general.task_timeout_seconds" => {
146            let timeout: u64 = value
147                .parse()
148                .map_err(|_| SubXError::config("Task timeout must be a positive integer"))?;
149            validate_range(timeout, 30, 3600)?;
150        }
151        "general.enable_progress_bar" => {
152            parse_bool(value)?;
153        }
154        "general.worker_idle_timeout_seconds" => {
155            let timeout: u64 = value
156                .parse()
157                .map_err(|_| SubXError::config("Worker idle timeout must be a positive integer"))?;
158            validate_range(timeout, 10, 3600)?;
159        }
160        "general.max_subtitle_bytes" => {
161            let bytes: u64 = value
162                .parse()
163                .map_err(|_| SubXError::config("max_subtitle_bytes must be a positive integer"))?;
164            validate_range(bytes, 1024_u64, 1_073_741_824_u64)?;
165        }
166        "general.max_audio_bytes" => {
167            let bytes: u64 = value
168                .parse()
169                .map_err(|_| SubXError::config("max_audio_bytes must be a positive integer"))?;
170            validate_range(bytes, 1024_u64, 10_737_418_240_u64)?;
171        }
172
173        // Parallel configuration fields
174        "parallel.max_workers" => {
175            let workers: usize = value
176                .parse()
177                .map_err(|_| SubXError::config("Max workers must be a positive integer"))?;
178            validate_range(workers, 1, 64)?;
179        }
180        "parallel.task_queue_size" => {
181            let size: usize = value
182                .parse()
183                .map_err(|_| SubXError::config("Task queue size must be a positive integer"))?;
184            validate_range(size, 100, 10000)?;
185        }
186        "parallel.enable_task_priorities" => {
187            parse_bool(value)?;
188        }
189        "parallel.auto_balance_workers" => {
190            parse_bool(value)?;
191        }
192        "parallel.overflow_strategy" => {
193            validate_enum(value, &["Block", "Drop", "Expand"])?;
194        }
195
196        _ => {
197            return Err(SubXError::config(format!(
198                "Unknown configuration key: {key}"
199            )));
200        }
201    }
202
203    Ok(())
204}
205
206/// Get a user-friendly description for a configuration field.
207pub fn get_field_description(key: &str) -> &'static str {
208    match key {
209        "ai.provider" => "AI service provider (e.g., 'openai', 'azure-openai')",
210        "ai.model" => "AI model name (e.g., 'gpt-4.1-mini')",
211        "ai.api_key" => "API key for the AI service",
212        "ai.base_url" => "Custom API endpoint URL (optional)",
213        "ai.temperature" => "AI response randomness (0.0-2.0)",
214        "ai.max_tokens" => "Maximum tokens in AI response",
215        "ai.max_sample_length" => "Maximum sample length for AI processing",
216        "ai.retry_attempts" => "Number of retry attempts for AI requests",
217        "ai.retry_delay_ms" => "Delay between retry attempts in milliseconds",
218        "ai.request_timeout_seconds" => "Request timeout in seconds",
219        "ai.api_version" => "Azure OpenAI API version (optional, defaults to latest)",
220
221        "sync.default_method" => "Synchronization method ('auto', 'vad', or 'manual')",
222        "sync.max_offset_seconds" => "Maximum allowed time offset in seconds",
223        "sync.vad.enabled" => "Enable voice activity detection",
224        "sync.vad.sensitivity" => "Voice activity detection threshold (0.0-1.0)",
225        "sync.vad.chunk_size" => "VAD processing chunk size (must be power of 2)",
226        "sync.vad.sample_rate" => "Audio sample rate for VAD processing",
227        "sync.vad.padding_chunks" => "Number of padding chunks for VAD",
228        "sync.vad.min_speech_duration_ms" => "Minimum speech duration in milliseconds",
229
230        "formats.default_output" => "Default output format for subtitles",
231        "formats.preserve_styling" => "Preserve subtitle styling information",
232        "formats.default_encoding" => "Default character encoding",
233        "formats.encoding_detection_confidence" => "Confidence threshold for encoding detection",
234
235        "general.backup_enabled" => "Enable automatic backup creation",
236        "general.max_concurrent_jobs" => "Maximum number of concurrent jobs",
237        "general.task_timeout_seconds" => "Task timeout in seconds",
238        "general.enable_progress_bar" => "Enable progress bar display",
239        "general.worker_idle_timeout_seconds" => "Worker idle timeout in seconds",
240        "general.max_subtitle_bytes" => "Maximum subtitle file size in bytes",
241        "general.max_audio_bytes" => "Maximum audio file size in bytes",
242
243        "parallel.max_workers" => "Maximum number of worker threads",
244        "parallel.task_queue_size" => "Size of the task queue",
245        "parallel.enable_task_priorities" => "Enable task priority system",
246        "parallel.auto_balance_workers" => "Enable automatic worker load balancing",
247        "parallel.overflow_strategy" => "Strategy for handling queue overflow",
248
249        _ => "Configuration field",
250    }
251}
252
253#[cfg(test)]
254mod tests {
255    use super::*;
256
257    #[test]
258    fn test_validate_ai_fields() {
259        // Valid cases
260        assert!(validate_field("ai.provider", "openai").is_ok());
261        assert!(validate_field("ai.provider", "openrouter").is_ok());
262        assert!(validate_field("ai.provider", "azure-openai").is_ok());
263        assert!(validate_field("ai.temperature", "0.8").is_ok());
264        assert!(validate_field("ai.max_tokens", "4000").is_ok());
265
266        // Invalid cases
267        assert!(validate_field("ai.provider", "invalid").is_err());
268        assert!(validate_field("ai.temperature", "3.0").is_err());
269        assert!(validate_field("ai.max_tokens", "0").is_err());
270    }
271
272    #[test]
273    fn test_validate_sync_fields() {
274        // Valid cases
275        assert!(validate_field("sync.default_method", "vad").is_ok());
276        assert!(validate_field("sync.vad.sensitivity", "0.5").is_ok());
277        assert!(validate_field("sync.vad.padding_chunks", "3").is_ok());
278
279        // Invalid cases
280        assert!(validate_field("sync.default_method", "invalid").is_err());
281        assert!(validate_field("sync.vad.sensitivity", "1.5").is_err());
282        assert!(validate_field("sync.vad.padding_chunks", "11").is_err()); // Exceeds max allowed padding_chunks
283    }
284
285    #[test]
286    fn test_validate_formats_fields() {
287        // Valid cases
288        assert!(validate_field("formats.default_output", "srt").is_ok());
289        assert!(validate_field("formats.preserve_styling", "true").is_ok());
290
291        // Invalid cases
292        assert!(validate_field("formats.default_output", "invalid").is_err());
293        assert!(validate_field("formats.preserve_styling", "maybe").is_err());
294    }
295
296    #[test]
297    fn test_validate_unknown_field() {
298        assert!(validate_field("unknown.field", "value").is_err());
299    }
300
301    #[test]
302    fn test_get_field_description() {
303        assert!(!get_field_description("ai.provider").is_empty());
304        assert!(!get_field_description("sync.vad.sensitivity").is_empty());
305        assert_eq!(
306            get_field_description("unknown.field"),
307            "Configuration field"
308        );
309    }
310}
subx_cli/config/field_validator.rs

subx_cli/config/
field_validator.rs
