add config-sqlite and http-api adapters

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.

crates/adapters/config-sqlite/tests/config_store_tests.rs

@@ -0,0 +1,203 @@
+use std::time::Duration;
+use domain::{
+    ConfigRepository, DisplayHint, KeyMapping, WidgetConfig,
+    DataSource, DataSourceConfig, DataSourceType,
+    Layout, LayoutNode, ContainerNode, LayoutChild, Direction, Sizing,
+    LayoutPreset,
+};
+use config_sqlite::SqliteConfigStore;
+
+async fn test_store() -> SqliteConfigStore {
+    SqliteConfigStore::new("sqlite::memory:").await.unwrap()
+}
+
+fn weather_widget() -> WidgetConfig {
+    WidgetConfig {
+        id: 1,
+        name: "weather".into(),
+        display_hint: DisplayHint::IconValue,
+        data_source_id: 10,
+        mappings: vec![
+            KeyMapping { source_path: "$.temp".into(), target_key: "temperature".into() },
+            KeyMapping { source_path: "$.icon".into(), target_key: "icon".into() },
+        ],
+        max_data_size: 2048,
+    }
+}
+
+fn weather_source() -> DataSource {
+    DataSource {
+        id: 10,
+        name: "openweather".into(),
+        source_type: DataSourceType::Weather,
+        poll_interval: Duration::from_secs(300),
+        config: DataSourceConfig {
+            url: Some("https://api.openweather.org".into()),
+            headers: vec![],
+            api_key: Some("test-key".into()),
+        },
+    }
+}
+
+fn test_layout() -> Layout {
+    Layout {
+        root: LayoutNode::Container(ContainerNode {
+            direction: Direction::Row,
+            gap: 4,
+            padding: 2,
+            children: vec![
+                LayoutChild { sizing: Sizing::Flex(1), node: LayoutNode::Leaf(1) },
+                LayoutChild { sizing: Sizing::Fixed(80), node: LayoutNode::Leaf(2) },
+            ],
+        }),
+    }
+}
+
+#[tokio::test]
+async fn save_and_retrieve_widget() {
+    let store = test_store().await;
+    store.save_widget(&weather_widget()).await.unwrap();
+
+    let w = store.get_widget(1).await.unwrap().unwrap();
+    assert_eq!(w.id, 1);
+    assert_eq!(w.name, "weather");
+    assert_eq!(w.display_hint, DisplayHint::IconValue);
+    assert_eq!(w.data_source_id, 10);
+    assert_eq!(w.mappings.len(), 2);
+    assert_eq!(w.mappings[0].source_path, "$.temp");
+    assert_eq!(w.max_data_size, 2048);
+}
+
+#[tokio::test]
+async fn get_nonexistent_widget_returns_none() {
+    let store = test_store().await;
+    assert!(store.get_widget(99).await.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn list_widgets_returns_all() {
+    let store = test_store().await;
+    store.save_widget(&weather_widget()).await.unwrap();
+    store.save_widget(&WidgetConfig {
+        id: 2,
+        name: "portfolio".into(),
+        display_hint: DisplayHint::KeyValue,
+        data_source_id: 20,
+        mappings: vec![],
+        max_data_size: 1024,
+    }).await.unwrap();
+
+    let widgets = store.list_widgets().await.unwrap();
+    assert_eq!(widgets.len(), 2);
+}
+
+#[tokio::test]
+async fn delete_widget_removes_it() {
+    let store = test_store().await;
+    store.save_widget(&weather_widget()).await.unwrap();
+    store.delete_widget(1).await.unwrap();
+    assert!(store.get_widget(1).await.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn save_and_retrieve_data_source() {
+    let store = test_store().await;
+    store.save_data_source(&weather_source()).await.unwrap();
+
+    let ds = store.get_data_source(10).await.unwrap().unwrap();
+    assert_eq!(ds.id, 10);
+    assert_eq!(ds.name, "openweather");
+    assert_eq!(ds.source_type, DataSourceType::Weather);
+    assert_eq!(ds.poll_interval, Duration::from_secs(300));
+    assert_eq!(ds.config.url, Some("https://api.openweather.org".into()));
+    assert_eq!(ds.config.api_key, Some("test-key".into()));
+}
+
+#[tokio::test]
+async fn list_and_delete_data_sources() {
+    let store = test_store().await;
+    store.save_data_source(&weather_source()).await.unwrap();
+    assert_eq!(store.list_data_sources().await.unwrap().len(), 1);
+
+    store.delete_data_source(10).await.unwrap();
+    assert!(store.list_data_sources().await.unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn save_and_retrieve_layout() {
+    let store = test_store().await;
+    let layout = test_layout();
+    store.save_layout(&layout).await.unwrap();
+
+    let loaded = store.get_layout().await.unwrap().unwrap();
+    assert_eq!(loaded, layout);
+}
+
+#[tokio::test]
+async fn layout_starts_as_none() {
+    let store = test_store().await;
+    assert!(store.get_layout().await.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn save_layout_replaces_previous() {
+    let store = test_store().await;
+    store.save_layout(&test_layout()).await.unwrap();
+
+    let new_layout = Layout {
+        root: LayoutNode::Leaf(42),
+    };
+    store.save_layout(&new_layout).await.unwrap();
+
+    let loaded = store.get_layout().await.unwrap().unwrap();
+    assert_eq!(loaded, new_layout);
+}
+
+#[tokio::test]
+async fn save_and_retrieve_preset() {
+    let store = test_store().await;
+    let preset = LayoutPreset {
+        id: 1,
+        name: "dashboard".into(),
+        layout: test_layout(),
+    };
+    store.save_preset(&preset).await.unwrap();
+
+    let loaded = store.get_preset(1).await.unwrap().unwrap();
+    assert_eq!(loaded.id, 1);
+    assert_eq!(loaded.name, "dashboard");
+    assert_eq!(loaded.layout, test_layout());
+}
+
+#[tokio::test]
+async fn list_and_delete_presets() {
+    let store = test_store().await;
+    store.save_preset(&LayoutPreset {
+        id: 1, name: "a".into(), layout: test_layout(),
+    }).await.unwrap();
+    store.save_preset(&LayoutPreset {
+        id: 2, name: "b".into(), layout: test_layout(),
+    }).await.unwrap();
+
+    assert_eq!(store.list_presets().await.unwrap().len(), 2);
+
+    store.delete_preset(1).await.unwrap();
+    assert_eq!(store.list_presets().await.unwrap().len(), 1);
+    assert!(store.get_preset(1).await.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn save_widget_updates_existing() {
+    let store = test_store().await;
+    store.save_widget(&weather_widget()).await.unwrap();
+
+    let mut updated = weather_widget();
+    updated.name = "updated_weather".into();
+    updated.max_data_size = 4096;
+    store.save_widget(&updated).await.unwrap();
+
+    let loaded = store.get_widget(1).await.unwrap().unwrap();
+    assert_eq!(loaded.name, "updated_weather");
+    assert_eq!(loaded.max_data_size, 4096);
+    assert_eq!(store.list_widgets().await.unwrap().len(), 1);
+}