armature-config 0.1.1

Configuration management for Armature with environment and file support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// ConfigService - High-level configuration service

use crate::{ConfigManager, Result};
use serde::de::DeserializeOwned;

/// High-level configuration service
#[derive(Clone)]
pub struct ConfigService {
    manager: ConfigManager,
}

impl ConfigService {
    /// Create a new configuration service
    pub fn new() -> Self {
        Self {
            manager: ConfigManager::new(),
        }
    }

    /// Create from an existing manager
    pub fn from_manager(manager: ConfigManager) -> Self {
        Self { manager }
    }

    /// Builder for creating configured service
    pub fn builder() -> ConfigServiceBuilder {
        ConfigServiceBuilder::new()
    }

    /// Get configuration value
    pub fn get<T: DeserializeOwned>(&self, key: &str) -> Result<T> {
        self.manager.get(key)
    }

    /// Get configuration value with default
    pub fn get_or<T: DeserializeOwned>(&self, key: &str, default: T) -> T {
        self.manager.get_or(key, default)
    }

    /// Get string value
    pub fn get_string(&self, key: &str) -> Result<String> {
        self.manager.get_string(key)
    }

    /// Get integer value
    pub fn get_int(&self, key: &str) -> Result<i64> {
        self.manager.get_int(key)
    }

    /// Get boolean value
    pub fn get_bool(&self, key: &str) -> Result<bool> {
        self.manager.get_bool(key)
    }

    /// Check if key exists
    pub fn has(&self, key: &str) -> bool {
        self.manager.has(key)
    }

    /// Get underlying manager
    pub fn manager(&self) -> &ConfigManager {
        &self.manager
    }
}

impl Default for ConfigService {
    fn default() -> Self {
        Self::new()
    }
}

/// Builder for ConfigService
pub struct ConfigServiceBuilder {
    manager: ConfigManager,
    load_env: bool,
    load_dotenv: bool,
    dotenv_path: Option<String>,
    config_files: Vec<(String, crate::FileFormat)>,
}

impl ConfigServiceBuilder {
    pub fn new() -> Self {
        Self {
            manager: ConfigManager::new(),
            load_env: false,
            load_dotenv: false,
            dotenv_path: None,
            config_files: Vec::new(),
        }
    }

    /// Set environment variable prefix
    pub fn with_prefix(mut self, prefix: String) -> Self {
        self.manager = ConfigManager::with_prefix(prefix);
        self
    }

    /// Enable loading from environment variables
    pub fn load_env(mut self) -> Self {
        self.load_env = true;
        self
    }

    /// Enable loading from .env file
    pub fn load_dotenv(mut self, path: Option<String>) -> Self {
        self.load_dotenv = true;
        self.dotenv_path = path;
        self
    }

    /// Add configuration file to load
    pub fn add_file(mut self, path: String, format: crate::FileFormat) -> Self {
        self.config_files.push((path, format));
        self
    }

    /// Build the configuration service
    pub fn build(self) -> Result<ConfigService> {
        // Load .env file first if specified
        if self.load_dotenv {
            let _ = self.manager.load_dotenv(self.dotenv_path.as_deref());
        }

        // Load environment variables
        if self.load_env {
            self.manager.load_env()?;
        }

        // Load configuration files
        for (path, format) in self.config_files {
            self.manager.load_file(&path, format)?;
        }

        Ok(ConfigService::from_manager(self.manager))
    }
}

impl Default for ConfigServiceBuilder {
    fn default() -> Self {
        Self::new()
    }
}