use crate::database::adapter::DatabaseAdapter;
use crate::error::{Error, Result};
use crate::models::query_builder::QueryBuilder;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
pub struct DatabaseRegistry {
adapters: Arc<RwLock<HashMap<String, Box<dyn DatabaseAdapter>>>>,
default: Arc<RwLock<Option<String>>>,
}
impl DatabaseRegistry {
pub fn new() -> Self {
Self {
adapters: Arc::new(RwLock::new(HashMap::new())),
default: Arc::new(RwLock::new(None)),
}
}
pub async fn register(
&self,
name: impl Into<String>,
adapter: Box<dyn DatabaseAdapter>,
set_as_default: bool,
) -> Result<()> {
let name = name.into();
let mut adapters = self.adapters.write().await;
adapters.insert(name.clone(), adapter);
if set_as_default || adapters.len() == 1 {
let mut default = self.default.write().await;
*default = Some(name);
}
Ok(())
}
pub async fn get(&self, name: &str) -> Option<Box<dyn DatabaseAdapter>> {
let adapters = self.adapters.read().await;
adapters.get(name).map(|adapter| adapter.clone_box())
}
pub async fn get_default(&self) -> Result<Box<dyn DatabaseAdapter>> {
let default = self.default.read().await;
match &*default {
Some(name) => self.get(name).await.ok_or_else(|| {
Error::template(format!("Default database '{}' not found in registry", name))
}),
None => Err(Error::template(
"No default database configured".to_string(),
)),
}
}
pub async fn set_default(&self, name: impl Into<String>) -> Result<()> {
let name = name.into();
let adapters = self.adapters.read().await;
if !adapters.contains_key(&name) {
return Err(Error::template(format!(
"Database '{}' not found in registry",
name
)));
}
drop(adapters);
let mut default = self.default.write().await;
*default = Some(name);
Ok(())
}
pub async fn query(&self, name: &str) -> Result<QueryBuilder> {
self.get(name)
.await
.map(|adapter| adapter.query())
.ok_or_else(|| Error::template(format!("Database '{}' not found", name)))
}
pub async fn query_default(&self) -> Result<QueryBuilder> {
let adapter = self.get_default().await?;
Ok(adapter.query())
}
pub async fn list_databases(&self) -> Vec<String> {
let adapters = self.adapters.read().await;
adapters.keys().cloned().collect()
}
pub async fn has_database(&self, name: &str) -> bool {
let adapters = self.adapters.read().await;
adapters.contains_key(name)
}
pub async fn remove(&self, name: &str) -> Result<()> {
let default = self.default.read().await;
if default.as_ref().map(|d| d == name).unwrap_or(false) {
return Err(Error::template(
"Cannot remove the default database. Set a different default first.".to_string(),
));
}
drop(default);
let mut adapters = self.adapters.write().await;
adapters
.remove(name)
.ok_or_else(|| Error::template(format!("Database '{}' not found", name)))?;
Ok(())
}
pub async fn clear(&self) {
let mut adapters = self.adapters.write().await;
adapters.clear();
let mut default = self.default.write().await;
*default = None;
}
pub async fn stats(&self) -> RegistryStats {
let adapters = self.adapters.read().await;
let default = self.default.read().await;
RegistryStats {
total_databases: adapters.len(),
default_database: default.clone(),
database_names: adapters.keys().cloned().collect(),
}
}
}
#[derive(Debug, Clone)]
pub struct RegistryStats {
pub total_databases: usize,
pub default_database: Option<String>,
pub database_names: Vec<String>,
}
impl Default for DatabaseRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_registry_creation() {
let registry = DatabaseRegistry::new();
let stats = registry.stats().await;
assert_eq!(stats.total_databases, 0);
assert!(stats.default_database.is_none());
assert!(stats.database_names.is_empty());
}
#[tokio::test]
async fn test_list_databases() {
let registry = DatabaseRegistry::new();
let databases = registry.list_databases().await;
assert!(databases.is_empty());
}
#[tokio::test]
async fn test_has_database() {
let registry = DatabaseRegistry::new();
assert!(!registry.has_database("test").await);
}
#[tokio::test]
async fn test_get_default_error() {
let registry = DatabaseRegistry::new();
let result = registry.get_default().await;
assert!(result.is_err());
}
}