Gabriel Kaszewski
e398c240a0
SQLite config store: full ConfigRepository impl with JSON serialization for mappings, layouts, data source configs. 12 integration tests. HTTP API: Axum REST endpoints for widgets, data sources, layout, presets. 6 integration tests using tower::oneshot. Port traits updated to return Send futures for Axum compatibility.
127 lines
3.7 KiB
Rust
127 lines
3.7 KiB
Rust
use std::sync::Mutex;
|
|
use std::collections::HashMap;
|
|
use domain::{
|
|
ConfigRepository, EventPublisher,
|
|
DataSource, DataSourceId, Layout, LayoutPreset, LayoutPresetId,
|
|
WidgetConfig, WidgetId, DomainEvent,
|
|
};
|
|
|
|
pub struct InMemoryConfigRepository {
|
|
widgets: Mutex<HashMap<WidgetId, WidgetConfig>>,
|
|
data_sources: Mutex<HashMap<DataSourceId, DataSource>>,
|
|
layout: Mutex<Option<Layout>>,
|
|
presets: Mutex<HashMap<LayoutPresetId, LayoutPreset>>,
|
|
}
|
|
|
|
impl InMemoryConfigRepository {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
widgets: Mutex::new(HashMap::new()),
|
|
data_sources: Mutex::new(HashMap::new()),
|
|
layout: Mutex::new(None),
|
|
presets: Mutex::new(HashMap::new()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Never;
|
|
|
|
impl std::fmt::Display for Never {
|
|
fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
impl ConfigRepository for InMemoryConfigRepository {
|
|
type Error = Never;
|
|
|
|
async fn get_widget(&self, id: WidgetId) -> Result<Option<WidgetConfig>, Self::Error> {
|
|
Ok(self.widgets.lock().unwrap().get(&id).cloned())
|
|
}
|
|
|
|
async fn list_widgets(&self) -> Result<Vec<WidgetConfig>, Self::Error> {
|
|
Ok(self.widgets.lock().unwrap().values().cloned().collect())
|
|
}
|
|
|
|
async fn save_widget(&self, config: &WidgetConfig) -> Result<(), Self::Error> {
|
|
self.widgets.lock().unwrap().insert(config.id, config.clone());
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_widget(&self, id: WidgetId) -> Result<(), Self::Error> {
|
|
self.widgets.lock().unwrap().remove(&id);
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_data_source(&self, id: DataSourceId) -> Result<Option<DataSource>, Self::Error> {
|
|
Ok(self.data_sources.lock().unwrap().get(&id).cloned())
|
|
}
|
|
|
|
async fn list_data_sources(&self) -> Result<Vec<DataSource>, Self::Error> {
|
|
Ok(self.data_sources.lock().unwrap().values().cloned().collect())
|
|
}
|
|
|
|
async fn save_data_source(&self, source: &DataSource) -> Result<(), Self::Error> {
|
|
self.data_sources.lock().unwrap().insert(source.id, source.clone());
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_data_source(&self, id: DataSourceId) -> Result<(), Self::Error> {
|
|
self.data_sources.lock().unwrap().remove(&id);
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_layout(&self) -> Result<Option<Layout>, Self::Error> {
|
|
Ok(self.layout.lock().unwrap().clone())
|
|
}
|
|
|
|
async fn save_layout(&self, layout: &Layout) -> Result<(), Self::Error> {
|
|
*self.layout.lock().unwrap() = Some(layout.clone());
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_preset(&self, id: LayoutPresetId) -> Result<Option<LayoutPreset>, Self::Error> {
|
|
Ok(self.presets.lock().unwrap().get(&id).cloned())
|
|
}
|
|
|
|
async fn list_presets(&self) -> Result<Vec<LayoutPreset>, Self::Error> {
|
|
Ok(self.presets.lock().unwrap().values().cloned().collect())
|
|
}
|
|
|
|
async fn save_preset(&self, preset: &LayoutPreset) -> Result<(), Self::Error> {
|
|
self.presets.lock().unwrap().insert(preset.id, preset.clone());
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_preset(&self, id: LayoutPresetId) -> Result<(), Self::Error> {
|
|
self.presets.lock().unwrap().remove(&id);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct InMemoryEventPublisher {
|
|
events: Mutex<Vec<DomainEvent>>,
|
|
}
|
|
|
|
impl InMemoryEventPublisher {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
events: Mutex::new(Vec::new()),
|
|
}
|
|
}
|
|
|
|
pub fn emitted(&self) -> Vec<DomainEvent> {
|
|
self.events.lock().unwrap().clone()
|
|
}
|
|
}
|
|
|
|
impl EventPublisher for InMemoryEventPublisher {
|
|
type Error = Never;
|
|
|
|
async fn publish(&self, event: DomainEvent) -> Result<(), Self::Error> {
|
|
self.events.lock().unwrap().push(event);
|
|
Ok(())
|
|
}
|
|
}
|