Struct BackboneConfig 

pub struct BackboneConfig {
    pub app: AppConfig,
    pub server: ServerConfig,
    pub database: HashMap<String, DatabaseConfig>,
    pub cache: HashMap<String, CacheConfig>,
    pub modules: ModulesConfig,
    pub logging: LoggingConfig,
    pub monitoring: MonitoringConfig,
    pub contexts: ContextsConfig,
    pub features: FeaturesConfig,
    pub security: SecurityConfig,
}

Main configuration struct for Backbone Framework

Contains all configuration sections needed to run a Backbone application. Supports loading from YAML, TOML, or JSON files with environment variable substitution.

Fields

app: AppConfig

Application metadata

server: ServerConfig

Server configuration

database: HashMap<String, DatabaseConfig>

Database configurations (keyed by name)

cache: HashMap<String, CacheConfig>

Cache configurations (keyed by name)

modules: ModulesConfig

Module configurations

logging: LoggingConfig

Logging configuration

monitoring: MonitoringConfig

Monitoring configuration

contexts: ContextsConfig

Cross-context communication

features: FeaturesConfig

Feature flags

security: SecurityConfig

Security settings

Implementations

impl BackboneConfig

pub fn from_file<P: AsRef<Path>>(path: P) -> ConfigResult<Self>

Load configuration from a file path

Supports YAML (.yml, .yaml), TOML (.toml), and JSON (.json) formats. Environment variables in the format ${VAR:default} are substituted.

Example

let config = BackboneConfig::from_file("config/application.yml")?;

pub fn from_file_with_env<P: AsRef<Path>>( base_path: P, env: &str, ) -> ConfigResult<Self>

Load configuration with environment-specific overrides

Loads base config from {base_path} and merges with {base_path}-{env}.{ext} if it exists.

Example

// Loads config/application.yml + config/application-development.yml
let config = BackboneConfig::from_file_with_env(
    "config/application.yml",
    "development"
)?;

pub fn from_env() -> ConfigResult<Self>

Load configuration from environment variables only

Uses default values and overrides with environment variables.

pub fn validate(&self) -> ConfigResult<()>

Validate the configuration

Returns an error if any critical configuration is invalid.

pub fn default_database(&self) -> Option<&DatabaseConfig>

Get the default database configuration

pub fn get_database(&self, name: &str) -> Option<&DatabaseConfig>

Get a database configuration by name

pub fn default_cache(&self) -> Option<&CacheConfig>

Get the default cache configuration

pub fn get_cache(&self, name: &str) -> Option<&CacheConfig>

Get a cache configuration by name

pub fn is_module_enabled(&self, module_name: &str) -> bool

Check if a module is enabled

pub fn environment(&self) -> &Environment

Get the current environment

pub fn is_production(&self) -> bool

Check if running in production

pub fn is_development(&self) -> bool

Check if running in development

pub fn is_debug(&self) -> bool

Check if debug mode is enabled

pub fn merge(self, other: Self) -> Self

Merge another configuration into this one

Values from other override values in self.

Trait Implementations

impl Clone for BackboneConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BackboneConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BackboneConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BackboneConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BackboneConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.