add SPA config UI, wire media/rss adapters, event-driven layout push

- React SPA: dashboard, data sources CRUD, widgets CRUD, layout builder,
  presets. TanStack Router + Query, shadcn/ui, Vite proxy to :3000
- wire media + rss adapters into polling loop, remove xtb source type
- media adapter: read username/password from headers, proper subsonic auth
- event handler: subscribe to LayoutChanged, push screen update to clients
- fix clippy warnings across workspace (Default impls, collapsible ifs,
  redundant closures, is_none_or, unused imports)

crates/adapters/http-api/src/lib.rs

@@ -1,9 +1,9 @@
 mod routes;
 
-use std::sync::Arc;
 use axum::Router;
-use tower_http::cors::CorsLayer;
 use domain::{ConfigRepository, EventPublisher};
+use std::sync::Arc;
+use tower_http::cors::CorsLayer;
 
 pub struct AppState<C, E> {
     pub config: Arc<C>,

crates/adapters/http-api/src/routes/data_sources.rs

@@ -1,54 +1,107 @@
+use crate::AppState;
+use api_types::DataSourceDto;
+use application::ConfigService;
 use axum::{
     extract::{Path, State},
     http::StatusCode,
     response::Json,
 };
 use domain::{ConfigRepository, EventPublisher};
-use application::ConfigService;
-use crate::AppState;
-use api_types::DataSourceDto;
 
 type S<C, E> = State<AppState<C, E>>;
 
-pub async fn list_data_sources<C, E>(State(state): S<C, E>) -> Result<Json<Vec<DataSourceDto>>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn list_data_sources<C, E>(
+    State(state): S<C, E>,
+) -> Result<Json<Vec<DataSourceDto>>, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let sources = state.config.list_data_sources().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let sources = state
+        .config
+        .list_data_sources()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(Json(sources.iter().map(DataSourceDto::from).collect()))
 }
 
-pub async fn get_data_source<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<Json<DataSourceDto>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn get_data_source<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<Json<DataSourceDto>, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let source = state.config.get_data_source(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let source = state
+        .config
+        .get_data_source(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     match source {
         Some(s) => Ok(Json(DataSourceDto::from(&s))),
         None => Err(StatusCode::NOT_FOUND),
     }
 }
 
-pub async fn create_data_source<C, E>(State(state): S<C, E>, Json(body): Json<DataSourceDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn create_data_source<C, E>(
+    State(state): S<C, E>,
+    Json(body): Json<DataSourceDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let source = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let source = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.create_data_source(source).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.create_data_source(source)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::CREATED)
 }
 
-pub async fn update_data_source<C, E>(State(state): S<C, E>, Path(_id): Path<u16>, Json(body): Json<DataSourceDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn update_data_source<C, E>(
+    State(state): S<C, E>,
+    Path(_id): Path<u16>,
+    Json(body): Json<DataSourceDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let source = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let source = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.update_data_source(source).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.update_data_source(source)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::OK)
 }
 
-pub async fn delete_data_source<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<StatusCode, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn delete_data_source<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<StatusCode, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.delete_data_source(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    svc.delete_data_source(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(StatusCode::NO_CONTENT)
 }

crates/adapters/http-api/src/routes/layout.rs

@@ -1,27 +1,42 @@
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json,
-};
-use domain::{ConfigRepository, EventPublisher};
-use application::ConfigService;
 use crate::AppState;
 use api_types::LayoutDto;
+use application::ConfigService;
+use axum::{extract::State, http::StatusCode, response::Json};
+use domain::{ConfigRepository, EventPublisher};
 
 type S<C, E> = State<AppState<C, E>>;
 
 pub async fn get_layout<C, E>(State(state): S<C, E>) -> Result<Json<Option<LayoutDto>>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let layout = state.config.get_layout().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let layout = state
+        .config
+        .get_layout()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(Json(layout.as_ref().map(LayoutDto::from)))
 }
 
-pub async fn update_layout<C, E>(State(state): S<C, E>, Json(body): Json<LayoutDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn update_layout<C, E>(
+    State(state): S<C, E>,
+    Json(body): Json<LayoutDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let layout = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let layout = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.update_layout(layout).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.update_layout(layout)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::OK)
 }

crates/adapters/http-api/src/routes/mod.rs

@@ -1,12 +1,12 @@
-mod widgets;
 mod data_sources;
 mod layout;
 mod presets;
+mod widgets;
 
-use axum::Router;
-use axum::routing::{get, post, put, delete};
-use domain::{ConfigRepository, EventPublisher};
 use crate::AppState;
+use axum::Router;
+use axum::routing::{get, post};
+use domain::{ConfigRepository, EventPublisher};
 
 pub fn api_routes<C, E>() -> Router<AppState<C, E>>
 where
@@ -16,12 +16,38 @@ where
     E::Error: std::fmt::Debug + Send,
 {
     Router::new()
-        .route("/widgets", get(widgets::list_widgets::<C, E>).post(widgets::create_widget::<C, E>))
-        .route("/widgets/{id}", get(widgets::get_widget::<C, E>).put(widgets::update_widget::<C, E>).delete(widgets::delete_widget::<C, E>))
-        .route("/data-sources", get(data_sources::list_data_sources::<C, E>).post(data_sources::create_data_source::<C, E>))
-        .route("/data-sources/{id}", get(data_sources::get_data_source::<C, E>).put(data_sources::update_data_source::<C, E>).delete(data_sources::delete_data_source::<C, E>))
-        .route("/layout", get(layout::get_layout::<C, E>).put(layout::update_layout::<C, E>))
-        .route("/presets", get(presets::list_presets::<C, E>).post(presets::create_preset::<C, E>))
-        .route("/presets/{id}", get(presets::get_preset::<C, E>).delete(presets::delete_preset::<C, E>))
+        .route(
+            "/widgets",
+            get(widgets::list_widgets::<C, E>).post(widgets::create_widget::<C, E>),
+        )
+        .route(
+            "/widgets/{id}",
+            get(widgets::get_widget::<C, E>)
+                .put(widgets::update_widget::<C, E>)
+                .delete(widgets::delete_widget::<C, E>),
+        )
+        .route(
+            "/data-sources",
+            get(data_sources::list_data_sources::<C, E>)
+                .post(data_sources::create_data_source::<C, E>),
+        )
+        .route(
+            "/data-sources/{id}",
+            get(data_sources::get_data_source::<C, E>)
+                .put(data_sources::update_data_source::<C, E>)
+                .delete(data_sources::delete_data_source::<C, E>),
+        )
+        .route(
+            "/layout",
+            get(layout::get_layout::<C, E>).put(layout::update_layout::<C, E>),
+        )
+        .route(
+            "/presets",
+            get(presets::list_presets::<C, E>).post(presets::create_preset::<C, E>),
+        )
+        .route(
+            "/presets/{id}",
+            get(presets::get_preset::<C, E>).delete(presets::delete_preset::<C, E>),
+        )
         .route("/presets/{id}/load", post(presets::load_preset::<C, E>))
 }

crates/adapters/http-api/src/routes/presets.rs

@@ -1,53 +1,101 @@
+use crate::AppState;
+use api_types::{CreatePresetDto, PresetDto};
+use application::ConfigService;
 use axum::{
     extract::{Path, State},
     http::StatusCode,
     response::Json,
 };
 use domain::{ConfigRepository, EventPublisher};
-use application::ConfigService;
-use crate::AppState;
-use api_types::{PresetDto, CreatePresetDto};
 
 type S<C, E> = State<AppState<C, E>>;
 
 pub async fn list_presets<C, E>(State(state): S<C, E>) -> Result<Json<Vec<PresetDto>>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let presets = state.config.list_presets().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let presets = state
+        .config
+        .list_presets()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(Json(presets.iter().map(PresetDto::from).collect()))
 }
 
-pub async fn get_preset<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<Json<PresetDto>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn get_preset<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<Json<PresetDto>, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let preset = state.config.get_preset(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let preset = state
+        .config
+        .get_preset(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     match preset {
         Some(p) => Ok(Json(PresetDto::from(&p))),
         None => Err(StatusCode::NOT_FOUND),
     }
 }
 
-pub async fn create_preset<C, E>(State(state): S<C, E>, Json(body): Json<CreatePresetDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn create_preset<C, E>(
+    State(state): S<C, E>,
+    Json(body): Json<CreatePresetDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let preset = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let preset = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.save_preset(preset).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.save_preset(preset)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::CREATED)
 }
 
-pub async fn delete_preset<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<StatusCode, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn delete_preset<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<StatusCode, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.delete_preset(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    svc.delete_preset(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(StatusCode::NO_CONTENT)
 }
 
-pub async fn load_preset<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn load_preset<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.load_preset(id).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.load_preset(id)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::OK)
 }

crates/adapters/http-api/src/routes/widgets.rs

@@ -1,54 +1,105 @@
+use crate::AppState;
+use api_types::{CreateWidgetDto, WidgetDto};
+use application::ConfigService;
 use axum::{
     extract::{Path, State},
     http::StatusCode,
     response::Json,
 };
 use domain::{ConfigRepository, EventPublisher};
-use application::ConfigService;
-use crate::AppState;
-use api_types::{WidgetDto, CreateWidgetDto};
 
 type S<C, E> = State<AppState<C, E>>;
 
 pub async fn list_widgets<C, E>(State(state): S<C, E>) -> Result<Json<Vec<WidgetDto>>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let widgets = state.config.list_widgets().await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let widgets = state
+        .config
+        .list_widgets()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(Json(widgets.iter().map(WidgetDto::from).collect()))
 }
 
-pub async fn get_widget<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<Json<WidgetDto>, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn get_widget<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<Json<WidgetDto>, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let widget = state.config.get_widget(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let widget = state
+        .config
+        .get_widget(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     match widget {
         Some(w) => Ok(Json(WidgetDto::from(&w))),
         None => Err(StatusCode::NOT_FOUND),
     }
 }
 
-pub async fn create_widget<C, E>(State(state): S<C, E>, Json(body): Json<CreateWidgetDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn create_widget<C, E>(
+    State(state): S<C, E>,
+    Json(body): Json<CreateWidgetDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let widget = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let widget = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.create_widget(widget).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.create_widget(widget)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::CREATED)
 }
 
-pub async fn update_widget<C, E>(State(state): S<C, E>, Path(_id): Path<u16>, Json(body): Json<CreateWidgetDto>) -> Result<StatusCode, (StatusCode, String)>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn update_widget<C, E>(
+    State(state): S<C, E>,
+    Path(_id): Path<u16>,
+    Json(body): Json<CreateWidgetDto>,
+) -> Result<StatusCode, (StatusCode, String)>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
-    let widget = body.into_domain().map_err(|e| (StatusCode::BAD_REQUEST, e))?;
+    let widget = body
+        .into_domain()
+        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.update_widget(widget).await.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
+    svc.update_widget(widget)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
     Ok(StatusCode::OK)
 }
 
-pub async fn delete_widget<C, E>(State(state): S<C, E>, Path(id): Path<u16>) -> Result<StatusCode, StatusCode>
-where C: ConfigRepository, C::Error: std::fmt::Debug, E: EventPublisher, E::Error: std::fmt::Debug,
+pub async fn delete_widget<C, E>(
+    State(state): S<C, E>,
+    Path(id): Path<u16>,
+) -> Result<StatusCode, StatusCode>
+where
+    C: ConfigRepository,
+    C::Error: std::fmt::Debug,
+    E: EventPublisher,
+    E::Error: std::fmt::Debug,
 {
     let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
-    svc.delete_widget(id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    svc.delete_widget(id)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
     Ok(StatusCode::NO_CONTENT)
 }