feat: ConfigSource enum, RwLock provider_registry, is_admin in UserResponse, available_provider_types

k-tv-backend/api/src/routes/auth/local.rs

@@ -86,6 +86,7 @@ pub(super) async fn me(CurrentUser(user): CurrentUser) -> Result<impl IntoRespon
         id: user.id,
         email: user.email.into_inner(),
         created_at: user.created_at,
+        is_admin: user.is_admin,
     }))
 }
 

k-tv-backend/api/src/routes/config.rs

@@ -9,21 +9,21 @@ pub fn router() -> Router<AppState> {
 }
 
 async fn get_config(State(state): State<AppState>) -> Json<ConfigResponse> {
-    let providers: Vec<ProviderInfo> = state
-        .provider_registry
+    let registry = state.provider_registry.read().await;
+
+    let providers: Vec<ProviderInfo> = registry
         .provider_ids()
         .into_iter()
         .filter_map(|id| {
-            state.provider_registry.capabilities(&id).map(|caps| ProviderInfo {
+            registry.capabilities(&id).map(|caps| ProviderInfo {
                 id: id.clone(),
                 capabilities: caps,
             })
         })
         .collect();
 
-    let primary_capabilities = state
-        .provider_registry
-        .capabilities(state.provider_registry.primary_id())
+    let primary_capabilities = registry
+        .capabilities(registry.primary_id())
         .unwrap_or(ProviderCapabilities {
             collections: false,
             series: false,
@@ -36,9 +36,16 @@ async fn get_config(State(state): State<AppState>) -> Json<ConfigResponse> {
             transcode: false,
         });
 
+    let mut available_provider_types = Vec::new();
+    #[cfg(feature = "jellyfin")]
+    available_provider_types.push("jellyfin".to_string());
+    #[cfg(feature = "local-files")]
+    available_provider_types.push("local_files".to_string());
+
     Json(ConfigResponse {
         allow_registration: state.config.allow_registration,
         providers,
         provider_capabilities: primary_capabilities,
+        available_provider_types,
     })
 }

k-tv-backend/api/src/routes/library.rs

@@ -151,13 +151,14 @@ async fn list_collections(
     Query(params): Query<CollectionsQuery>,
 ) -> Result<Json<Vec<CollectionResponse>>, ApiError> {
     let provider_id = params.provider.as_deref().unwrap_or("");
-    let caps = state.provider_registry.capabilities(provider_id).ok_or_else(|| {
+    let registry = state.provider_registry.read().await;
+    let caps = registry.capabilities(provider_id).ok_or_else(|| {
         ApiError::validation(format!("Unknown provider '{}'", provider_id))
     })?;
     if !caps.collections {
         return Err(ApiError::not_implemented("collections not supported by this provider"));
     }
-    let collections = state.provider_registry.list_collections(provider_id).await?;
+    let collections = registry.list_collections(provider_id).await?;
     Ok(Json(collections.into_iter().map(Into::into).collect()))
 }
 
@@ -168,14 +169,14 @@ async fn list_series(
     Query(params): Query<SeriesQuery>,
 ) -> Result<Json<Vec<SeriesResponse>>, ApiError> {
     let provider_id = params.provider.as_deref().unwrap_or("");
-    let caps = state.provider_registry.capabilities(provider_id).ok_or_else(|| {
+    let registry = state.provider_registry.read().await;
+    let caps = registry.capabilities(provider_id).ok_or_else(|| {
         ApiError::validation(format!("Unknown provider '{}'", provider_id))
     })?;
     if !caps.series {
         return Err(ApiError::not_implemented("series not supported by this provider"));
     }
-    let series = state
-        .provider_registry
+    let series = registry
         .list_series(provider_id, params.collection.as_deref())
         .await?;
     Ok(Json(series.into_iter().map(Into::into).collect()))
@@ -188,14 +189,15 @@ async fn list_genres(
     Query(params): Query<GenresQuery>,
 ) -> Result<Json<Vec<String>>, ApiError> {
     let provider_id = params.provider.as_deref().unwrap_or("");
-    let caps = state.provider_registry.capabilities(provider_id).ok_or_else(|| {
+    let registry = state.provider_registry.read().await;
+    let caps = registry.capabilities(provider_id).ok_or_else(|| {
         ApiError::validation(format!("Unknown provider '{}'", provider_id))
     })?;
     if !caps.genres {
         return Err(ApiError::not_implemented("genres not supported by this provider"));
     }
     let ct = parse_content_type(params.content_type.as_deref())?;
-    let genres = state.provider_registry.list_genres(provider_id, ct.as_ref()).await?;
+    let genres = registry.list_genres(provider_id, ct.as_ref()).await?;
     Ok(Json(genres))
 }
 
@@ -228,7 +230,8 @@ async fn search_items(
         ..Default::default()
     };
 
-    let mut items = state.provider_registry.fetch_items(provider_id, &filter).await?;
+    let registry = state.provider_registry.read().await;
+    let mut items = registry.fetch_items(provider_id, &filter).await?;
 
     // Apply the same ordering the schedule engine uses so the preview reflects
     // what will actually be scheduled rather than raw provider order.