use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatabaseConnectionConfig {
pub url: String,
#[serde(default = "default_max_connections")]
pub max_connections: u32,
#[serde(default = "default_min_connections")]
pub min_connections: u32,
#[serde(default = "default_connect_timeout")]
pub connect_timeout: u64,
#[serde(default = "default_idle_timeout")]
pub idle_timeout: u64,
#[serde(default = "default_max_lifetime")]
pub max_lifetime: u64,
#[serde(default)]
pub is_default: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DatabasesConfig {
#[serde(flatten)]
pub databases: HashMap<String, DatabaseConnectionConfig>,
}
impl DatabasesConfig {
pub fn new() -> Self {
Self {
databases: HashMap::new(),
}
}
pub fn add_database(&mut self, name: impl Into<String>, config: DatabaseConnectionConfig) {
self.databases.insert(name.into(), config);
}
pub fn get(&self, name: &str) -> Option<&DatabaseConnectionConfig> {
self.databases.get(name)
}
pub fn get_default(&self) -> Option<(&String, &DatabaseConnectionConfig)> {
for (name, config) in &self.databases {
if config.is_default {
return Some((name, config));
}
}
self.databases.iter().next()
}
pub fn is_empty(&self) -> bool {
self.databases.is_empty()
}
pub fn len(&self) -> usize {
self.databases.len()
}
pub fn list_names(&self) -> Vec<String> {
self.databases.keys().cloned().collect()
}
pub fn merge(&mut self, other: DatabasesConfig) {
for (name, config) in other.databases {
self.databases.insert(name, config);
}
}
pub fn from_legacy(url: Option<String>, max_connections: Option<u32>) -> Self {
let mut config = Self::new();
if let Some(url) = url {
let db_config = DatabaseConnectionConfig {
url,
max_connections: max_connections.unwrap_or_else(default_max_connections),
min_connections: default_min_connections(),
connect_timeout: default_connect_timeout(),
idle_timeout: default_idle_timeout(),
max_lifetime: default_max_lifetime(),
is_default: true,
};
config.add_database("primary", db_config);
}
config
}
}
fn default_max_connections() -> u32 {
10
}
fn default_min_connections() -> u32 {
1
}
fn default_connect_timeout() -> u64 {
30
}
fn default_idle_timeout() -> u64 {
600
} fn default_max_lifetime() -> u64 {
1800
}
pub struct DatabaseConnectionConfigBuilder {
url: Option<String>,
max_connections: u32,
min_connections: u32,
connect_timeout: u64,
idle_timeout: u64,
max_lifetime: u64,
is_default: bool,
}
impl DatabaseConnectionConfigBuilder {
pub fn new() -> Self {
Self {
url: None,
max_connections: default_max_connections(),
min_connections: default_min_connections(),
connect_timeout: default_connect_timeout(),
idle_timeout: default_idle_timeout(),
max_lifetime: default_max_lifetime(),
is_default: false,
}
}
pub fn url(mut self, url: impl Into<String>) -> Self {
self.url = Some(url.into());
self
}
pub fn max_connections(mut self, max: u32) -> Self {
self.max_connections = max;
self
}
pub fn min_connections(mut self, min: u32) -> Self {
self.min_connections = min;
self
}
pub fn connect_timeout(mut self, timeout: u64) -> Self {
self.connect_timeout = timeout;
self
}
pub fn idle_timeout(mut self, timeout: u64) -> Self {
self.idle_timeout = timeout;
self
}
pub fn max_lifetime(mut self, lifetime: u64) -> Self {
self.max_lifetime = lifetime;
self
}
pub fn is_default(mut self, is_default: bool) -> Self {
self.is_default = is_default;
self
}
pub fn build(self) -> Result<DatabaseConnectionConfig, String> {
let url = self.url.ok_or("Database URL is required")?;
Ok(DatabaseConnectionConfig {
url,
max_connections: self.max_connections,
min_connections: self.min_connections,
connect_timeout: self.connect_timeout,
idle_timeout: self.idle_timeout,
max_lifetime: self.max_lifetime,
is_default: self.is_default,
})
}
}
impl Default for DatabaseConnectionConfigBuilder {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_empty_config() {
let config = DatabasesConfig::new();
assert!(config.is_empty());
assert_eq!(config.len(), 0);
}
#[test]
fn test_add_database() {
let mut config = DatabasesConfig::new();
let db_config = DatabaseConnectionConfig {
url: "postgresql://localhost/test".to_string(),
max_connections: 20,
min_connections: 5,
connect_timeout: 30,
idle_timeout: 600,
max_lifetime: 1800,
is_default: true,
};
config.add_database("primary", db_config.clone());
assert_eq!(config.len(), 1);
assert!(!config.is_empty());
assert_eq!(config.get("primary").unwrap().url, db_config.url);
}
#[test]
fn test_get_default() {
let mut config = DatabasesConfig::new();
config.add_database(
"secondary",
DatabaseConnectionConfig {
url: "mysql://localhost/secondary".to_string(),
max_connections: 10,
min_connections: 1,
connect_timeout: 30,
idle_timeout: 600,
max_lifetime: 1800,
is_default: false,
},
);
config.add_database(
"primary",
DatabaseConnectionConfig {
url: "postgresql://localhost/primary".to_string(),
max_connections: 20,
min_connections: 5,
connect_timeout: 30,
idle_timeout: 600,
max_lifetime: 1800,
is_default: true,
},
);
let (name, _) = config.get_default().unwrap();
assert_eq!(name, "primary");
}
#[test]
fn test_from_legacy() {
let config = DatabasesConfig::from_legacy(
Some("postgresql://localhost/legacy".to_string()),
Some(25),
);
assert_eq!(config.len(), 1);
let (name, db_config) = config.get_default().unwrap();
assert_eq!(name, "primary");
assert_eq!(db_config.url, "postgresql://localhost/legacy");
assert_eq!(db_config.max_connections, 25);
assert!(db_config.is_default);
}
#[test]
fn test_builder() {
let config = DatabaseConnectionConfigBuilder::new()
.url("sqlite://./test.db")
.max_connections(5)
.min_connections(1)
.is_default(true)
.build()
.unwrap();
assert_eq!(config.url, "sqlite://./test.db");
assert_eq!(config.max_connections, 5);
assert_eq!(config.min_connections, 1);
assert!(config.is_default);
}
}