GKaszewski/k-tv
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

collapse 20 pass-through use cases; handlers call ports directly

Browse Source 
delete get/list/list_by_owner channels, get_settings/activity_log admin,
get_item/get_sync_status/list_collections/list_seasons/list_shows/list_genres library,
get/list/delete providers, get/list/patch_label config_snapshots,
get_active/list_history/delete_after schedule — all single-delegation.

remove ChannelQueryDeps, LibraryQueryDeps, deleted query/command structs.
add direct port fields to AppState. update MCP crate accordingly.
This commit is contained in:
Gabriel Kaszewski
2026-07-12 07:18:26 +02:00
parent a6558e15b2
commit e2393be635
68 changed files with 191 additions and 1589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crates/application/src/library/deps.rs
View File

@@ -9,7 +9,3 @@ pub struct LibraryCommandDeps {
pub provider_registry: Arc<dyn IProviderRegistry>,
pub event_publisher: Arc<dyn EventPublisher>,
}
pub struct LibraryQueryDeps {
pub library_query: Arc<dyn LibraryQuery>,
}

16
crates/application/src/library/get_item.rs
View File

@@ -1,16 +0,0 @@
use domain::models::MediaItem;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::queries::GetItemQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: GetItemQuery,
) -> DomainResult<Option<MediaItem>> {
deps.library_query.get_by_id(&query.item_id).await
}
#[cfg(test)]
#[path = "tests/get_item.rs"]
mod tests;

16
crates/application/src/library/get_sync_status.rs
View File

@@ -1,16 +0,0 @@
use domain::models::LibrarySyncLogEntry;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::queries::GetSyncStatusQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
_query: GetSyncStatusQuery,
) -> DomainResult<Vec<LibrarySyncLogEntry>> {
deps.library_query.latest_sync_status().await
}
#[cfg(test)]
#[path = "tests/get_sync_status.rs"]
mod tests;

18
crates/application/src/library/list_collections.rs
View File

@@ -1,18 +0,0 @@
use domain::models::LibraryCollection;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::queries::ListCollectionsQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: ListCollectionsQuery,
) -> DomainResult<Vec<LibraryCollection>> {
deps.library_query
.list_collections(query.provider_id.as_deref())
.await
}
#[cfg(test)]
#[path = "tests/list_collections.rs"]
mod tests;

21
crates/application/src/library/list_genres.rs
View File

@@ -1,21 +0,0 @@
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::parse_content_type;
use super::queries::ListGenresQuery;
pub async fn execute(deps: &LibraryQueryDeps, query: ListGenresQuery) -> DomainResult<Vec<String>> {
let content_type = query
.content_type
.as_deref()
.map(parse_content_type)
.transpose()?;
deps.library_query
.list_genres(content_type.as_ref(), query.provider_id.as_deref())
.await
}
#[cfg(test)]
#[path = "tests/list_genres.rs"]
mod tests;

18
crates/application/src/library/list_seasons.rs
View File

@@ -1,18 +0,0 @@
use domain::models::SeasonSummary;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::queries::ListSeasonsQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: ListSeasonsQuery,
) -> DomainResult<Vec<SeasonSummary>> {
deps.library_query
.list_seasons(&query.series_name, query.provider_id.as_deref())
.await
}
#[cfg(test)]
#[path = "tests/list_seasons.rs"]
mod tests;

22
crates/application/src/library/list_shows.rs
View File

@@ -1,22 +0,0 @@
use domain::models::ShowSummary;
use domain::DomainResult;
use super::deps::LibraryQueryDeps;
use super::queries::ListShowsQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
query: ListShowsQuery,
) -> DomainResult<Vec<ShowSummary>> {
deps.library_query
.list_shows(
query.provider_id.as_deref(),
query.search_term.as_deref(),
&query.genres,
)
.await
}
#[cfg(test)]
#[path = "tests/list_shows.rs"]
mod tests;

15
crates/application/src/library/mod.rs
View File

@@ -1,26 +1,17 @@
pub mod commands;
pub mod deps;
pub mod get_item;
pub mod get_sync_status;
pub mod list_collections;
pub mod list_genres;
pub mod list_seasons;
pub mod list_shows;
pub mod queries;
pub mod search;
pub mod sync;
pub use commands::TriggerSyncCommand;
pub use deps::{LibraryCommandDeps, LibraryQueryDeps};
pub use queries::{
GetItemQuery, GetSyncStatusQuery, ListCollectionsQuery, ListGenresQuery, ListSeasonsQuery,
ListShowsQuery, SearchItemsQuery,
};
pub use deps::LibraryCommandDeps;
pub use queries::SearchItemsQuery;
use domain::errors::{DomainError, DomainResult};
use domain::value_objects::ContentType;
pub(crate) fn parse_content_type(s: &str) -> DomainResult<ContentType> {
pub fn parse_content_type(s: &str) -> DomainResult<ContentType> {
match s {
"movie" => Ok(ContentType::Movie),
"episode" => Ok(ContentType::Episode),

26
crates/application/src/library/queries.rs
View File

@@ -10,29 +10,3 @@ pub struct SearchItemsQuery {
pub offset: u32,
pub limit: u32,
}
pub struct ListCollectionsQuery {
pub provider_id: Option<String>,
}
pub struct ListShowsQuery {
pub provider_id: Option<String>,
pub search_term: Option<String>,
pub genres: Vec<String>,
}
pub struct ListSeasonsQuery {
pub series_name: String,
pub provider_id: Option<String>,
}
pub struct ListGenresQuery {
pub content_type: Option<String>,
pub provider_id: Option<String>,
}
pub struct GetItemQuery {
pub item_id: String,
}
pub struct GetSyncStatusQuery;

4
crates/application/src/library/search.rs
View File

@@ -2,12 +2,12 @@ use domain::DomainResult;
use domain::models::MediaItem;
use domain::value_objects::LibrarySearchFilter;
use super::deps::LibraryQueryDeps;
use super::deps::LibraryCommandDeps;
use super::parse_content_type;
use super::queries::SearchItemsQuery;
pub async fn execute(
deps: &LibraryQueryDeps,
deps: &LibraryCommandDeps,
query: SearchItemsQuery,
) -> DomainResult<(Vec<MediaItem>, u32)> {
let content_type = query

50
crates/application/src/library/tests/get_item.rs
View File

@@ -1,50 +0,0 @@
use domain::models::MediaItem;
use domain::value_objects::ContentType;
use crate::library::get_item;
use crate::library::queries::GetItemQuery;
#[path = "helpers.rs"]
mod helpers;
fn seed_item(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let item = MediaItem::new_library("test", "m1", "Die Hard", ContentType::Movie, 7800, "2026-01-01");
repo.items
.lock()
.unwrap()
.insert(item.id().value().to_string(), item);
}
#[tokio::test]
async fn get_existing_item() {
let (_cmd, query, repo) = helpers::make_deps();
seed_item(&repo);
let item = get_item::execute(
&query,
GetItemQuery {
item_id: "test::m1".into(),
},
)
.await
.unwrap();
assert!(item.is_some());
assert_eq!(item.unwrap().title(), "Die Hard");
}
#[tokio::test]
async fn get_nonexistent_item_returns_none() {
let (_cmd, query, _repo) = helpers::make_deps();
let item = get_item::execute(
&query,
GetItemQuery {
item_id: "test::missing".into(),
},
)
.await
.unwrap();
assert!(item.is_none());
}

41
crates/application/src/library/tests/get_sync_status.rs
View File

@@ -1,41 +0,0 @@
use crate::library::get_sync_status;
use crate::library::queries::GetSyncStatusQuery;
#[path = "helpers.rs"]
mod helpers;
#[tokio::test]
async fn get_sync_status_empty() {
let (_cmd, query, _repo) = helpers::make_deps();
let entries = get_sync_status::execute(&query, GetSyncStatusQuery)
.await
.unwrap();
assert!(entries.is_empty());
}
#[tokio::test]
async fn get_sync_status_after_sync() {
let (cmd, query, _repo) = helpers::make_deps();
// Start a sync log entry
let log_id = domain::ports::LibraryCommand::log_sync_start(&*cmd.library_command, "test")
.await
.unwrap();
// Finish it
let result = domain::models::LibrarySyncResult::new("test", 42, 500);
domain::ports::LibraryCommand::log_sync_finish(&*cmd.library_command, log_id, &result)
.await
.unwrap();
let entries = get_sync_status::execute(&query, GetSyncStatusQuery)
.await
.unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].provider_id(), "test");
assert_eq!(entries[0].items_found(), 42);
assert_eq!(entries[0].status(), "success");
}

19
crates/application/src/library/tests/helpers.rs
View File

@@ -11,9 +11,8 @@ use domain::ports::{
use domain::testing::{InMemoryLibraryRepository, NoopEventPublisher, NoopLibrarySync};
use domain::value_objects::{ContentType, MediaFilter, MediaItemId};
use crate::library::deps::{LibraryCommandDeps, LibraryQueryDeps};
use crate::library::deps::LibraryCommandDeps;
/// Minimal IProviderRegistry for library tests.
pub(crate) struct TestProviderRegistry;
#[async_trait]
@@ -83,24 +82,14 @@ impl IProviderRegistry for TestProviderRegistry {
}
}
/// Build LibraryCommandDeps and LibraryQueryDeps backed by InMemory repos.
///
/// Returns deps plus the underlying repo for seeding test data.
pub(crate) fn make_deps() -> (
LibraryCommandDeps,
LibraryQueryDeps,
Arc<InMemoryLibraryRepository>,
) {
pub(crate) fn make_deps() -> (LibraryCommandDeps, Arc<InMemoryLibraryRepository>) {
let repo = Arc::new(InMemoryLibraryRepository::new());
let cmd_deps = LibraryCommandDeps {
let deps = LibraryCommandDeps {
library_command: repo.clone(),
library_query: repo.clone(),
library_sync: Arc::new(NoopLibrarySync::new()),
provider_registry: Arc::new(TestProviderRegistry),
event_publisher: Arc::new(NoopEventPublisher::new()),
};
let query_deps = LibraryQueryDeps {
library_query: repo.clone(),
};
(cmd_deps, query_deps, repo)
(deps, repo)
}

87
crates/application/src/library/tests/list_collections.rs
View File

@@ -1,87 +0,0 @@
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_collections;
use crate::library::queries::ListCollectionsQuery;
#[path = "helpers.rs"]
mod helpers;
fn seed_with_collections(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m1"),
provider_id: "test".into(),
external_id: "m1".into(),
title: "Die Hard".into(),
content_type: ContentType::Movie,
duration_secs: 7800,
description: None,
series_name: None,
season_number: None,
episode_number: None,
year: None,
genres: vec![],
tags: vec![],
collection_id: Some("col-1".into()),
collection_name: Some("Movies".into()),
collection_type: Some("movies".into()),
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().value().to_string(), item);
let item2 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::e1"),
provider_id: "test".into(),
external_id: "e1".into(),
title: "BB S01E01".into(),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some("Breaking Bad".into()),
season_number: Some(1),
episode_number: Some(1),
year: None,
genres: vec![],
tags: vec![],
collection_id: Some("col-2".into()),
collection_name: Some("TV Shows".into()),
collection_type: Some("tvshows".into()),
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item2.id().value().to_string(), item2);
}
#[tokio::test]
async fn list_collections_returns_distinct() {
let (_cmd, query, repo) = helpers::make_deps();
seed_with_collections(&repo);
let cols = list_collections::execute(
&query,
ListCollectionsQuery { provider_id: None },
)
.await
.unwrap();
assert_eq!(cols.len(), 2);
}
#[tokio::test]
async fn list_collections_empty_library() {
let (_cmd, query, _repo) = helpers::make_deps();
let cols = list_collections::execute(
&query,
ListCollectionsQuery { provider_id: None },
)
.await
.unwrap();
assert!(cols.is_empty());
}

112
crates/application/src/library/tests/list_genres.rs
View File

@@ -1,112 +0,0 @@
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_genres;
use crate::library::queries::ListGenresQuery;
#[path = "helpers.rs"]
mod helpers;
fn seed_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
let item1 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m1"),
provider_id: "test".into(),
external_id: "m1".into(),
title: "Die Hard".into(),
content_type: ContentType::Movie,
duration_secs: 7800,
description: None,
series_name: None,
season_number: None,
episode_number: None,
year: None,
genres: vec!["Action".into(), "Thriller".into()],
tags: vec![],
collection_id: None,
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
let item2 = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new("test::m2"),
provider_id: "test".into(),
external_id: "m2".into(),
title: "Alien".into(),
content_type: ContentType::Movie,
duration_secs: 7020,
description: None,
series_name: None,
season_number: None,
episode_number: None,
year: None,
genres: vec!["Sci-Fi".into(), "Action".into()],
tags: vec![],
collection_id: None,
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item1.id().value().to_string(), item1);
store.insert(item2.id().value().to_string(), item2);
}
#[tokio::test]
async fn list_genres_returns_unique() {
let (_cmd, query, repo) = helpers::make_deps();
seed_with_genres(&repo);
let genres = list_genres::execute(
&query,
ListGenresQuery {
content_type: None,
provider_id: None,
},
)
.await
.unwrap();
assert_eq!(genres.len(), 3); // Action, Sci-Fi, Thriller (deduped)
assert!(genres.contains(&"Action".to_string()));
assert!(genres.contains(&"Sci-Fi".to_string()));
assert!(genres.contains(&"Thriller".to_string()));
}
#[tokio::test]
async fn list_genres_empty_library() {
let (_cmd, query, _repo) = helpers::make_deps();
let genres = list_genres::execute(
&query,
ListGenresQuery {
content_type: None,
provider_id: None,
},
)
.await
.unwrap();
assert!(genres.is_empty());
}
#[tokio::test]
async fn list_genres_invalid_content_type_errors() {
let (_cmd, query, _repo) = helpers::make_deps();
let result = list_genres::execute(
&query,
ListGenresQuery {
content_type: Some("invalid".into()),
provider_id: None,
},
)
.await;
assert!(result.is_err());
}

79
crates/application/src/library/tests/list_seasons.rs
View File

@@ -1,79 +0,0 @@
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_seasons;
use crate::library::queries::ListSeasonsQuery;
#[path = "helpers.rs"]
mod helpers;
fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
for (i, season) in [1u32, 1, 2, 2, 2, 3].iter().enumerate() {
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new(format!("test::e{i}")),
provider_id: "test".into(),
external_id: format!("e{i}"),
title: format!("BB S{season:02}E{:02}", i + 1),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some("Breaking Bad".into()),
season_number: Some(*season),
episode_number: Some(i as u32 + 1),
year: None,
genres: vec![],
tags: vec![],
collection_id: None,
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().value().to_string(), item);
}
}
#[tokio::test]
async fn list_seasons_for_series() {
let (_cmd, query, repo) = helpers::make_deps();
seed_episodes(&repo);
let seasons = list_seasons::execute(
&query,
ListSeasonsQuery {
series_name: "Breaking Bad".into(),
provider_id: None,
},
)
.await
.unwrap();
assert_eq!(seasons.len(), 3);
// Sorted by season_number
assert_eq!(seasons[0].season_number(), 1);
assert_eq!(seasons[0].episode_count(), 2);
assert_eq!(seasons[1].season_number(), 2);
assert_eq!(seasons[1].episode_count(), 3);
assert_eq!(seasons[2].season_number(), 3);
assert_eq!(seasons[2].episode_count(), 1);
}
#[tokio::test]
async fn list_seasons_unknown_series() {
let (_cmd, query, _repo) = helpers::make_deps();
let seasons = list_seasons::execute(
&query,
ListSeasonsQuery {
series_name: "Nonexistent".into(),
provider_id: None,
},
)
.await
.unwrap();
assert!(seasons.is_empty());
}

103
crates/application/src/library/tests/list_shows.rs
View File

@@ -1,103 +0,0 @@
use domain::models::{MediaItem, MediaItemRow};
use domain::value_objects::{ContentType, MediaItemId, MediaRole};
use crate::library::list_shows;
use crate::library::queries::ListShowsQuery;
#[path = "helpers.rs"]
mod helpers;
fn seed_episodes(repo: &std::sync::Arc<domain::testing::InMemoryLibraryRepository>) {
let mut store = repo.items.lock().unwrap();
for (i, (series, season)) in [
("Breaking Bad", 1u32),
("Breaking Bad", 1),
("Breaking Bad", 2),
("The Wire", 1),
("The Wire", 1),
]
.iter()
.enumerate()
{
let item = MediaItem::from_persistence(MediaItemRow {
id: MediaItemId::new(format!("test::e{i}")),
provider_id: "test".into(),
external_id: format!("e{i}"),
title: format!("{series} S{season:02}E{i:02}"),
content_type: ContentType::Episode,
duration_secs: 2700,
description: None,
series_name: Some(series.to_string()),
season_number: Some(*season),
episode_number: Some(i as u32 + 1),
year: None,
genres: vec![],
tags: vec![],
collection_id: None,
collection_name: None,
collection_type: None,
thumbnail_url: None,
synced_at: Some("2026-01-01".into()),
role: MediaRole::default(),
});
store.insert(item.id().value().to_string(), item);
}
}
#[tokio::test]
async fn list_shows_returns_summaries() {
let (_cmd, query, repo) = helpers::make_deps();
seed_episodes(&repo);
let shows = list_shows::execute(
&query,
ListShowsQuery {
provider_id: None,
search_term: None,
genres: vec![],
},
)
.await
.unwrap();
assert_eq!(shows.len(), 2);
}
#[tokio::test]
async fn list_shows_with_search_term() {
let (_cmd, query, repo) = helpers::make_deps();
seed_episodes(&repo);
let shows = list_shows::execute(
&query,
ListShowsQuery {
provider_id: None,
search_term: Some("breaking".into()),
genres: vec![],
},
)
.await
.unwrap();
assert_eq!(shows.len(), 1);
assert_eq!(shows[0].series_name(), "Breaking Bad");
}
#[tokio::test]
async fn list_shows_empty() {
let (_cmd, query, _repo) = helpers::make_deps();
let shows = list_shows::execute(
&query,
ListShowsQuery {
provider_id: None,
search_term: None,
genres: vec![],
},
)
.await
.unwrap();
assert!(shows.is_empty());
}

24
crates/application/src/library/tests/search.rs
View File

@@ -93,11 +93,11 @@ fn seed_items_with_genres(repo: &std::sync::Arc<domain::testing::InMemoryLibrary
#[tokio::test]
async fn search_empty_filter_returns_all() {
let (_cmd, query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
seed_items(&repo);
let (items, total) = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: None,
@@ -120,11 +120,11 @@ async fn search_empty_filter_returns_all() {
#[tokio::test]
async fn search_by_content_type() {
let (_cmd, query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
seed_items(&repo);
let (items, total) = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: Some("movie".into()),
@@ -147,11 +147,11 @@ async fn search_by_content_type() {
#[tokio::test]
async fn search_by_genre() {
let (_cmd, query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
seed_items_with_genres(&repo);
let (items, total) = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: None,
@@ -175,11 +175,11 @@ async fn search_by_genre() {
#[tokio::test]
async fn search_by_search_term() {
let (_cmd, query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
seed_items(&repo);
let (items, total) = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: None,
@@ -203,10 +203,10 @@ async fn search_by_search_term() {
#[tokio::test]
async fn search_invalid_content_type_errors() {
let (_cmd, query, _repo) = helpers::make_deps();
let (deps, _repo) = helpers::make_deps();
let result = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: Some("bogus".into()),
@@ -227,11 +227,11 @@ async fn search_invalid_content_type_errors() {
#[tokio::test]
async fn search_pagination() {
let (_cmd, query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
seed_items(&repo);
let (items, total) = search::execute(
&query,
&deps,
SearchItemsQuery {
provider_id: None,
content_type: None,

17
crates/application/src/library/tests/sync.rs
View File

@@ -6,10 +6,10 @@ mod helpers;
#[tokio::test]
async fn trigger_sync_returns_provider_ids() {
let (cmd, _query, _repo) = helpers::make_deps();
let (deps, _repo) = helpers::make_deps();
let ids = sync::execute(
&cmd,
&deps,
TriggerSyncCommand { provider_id: None },
)
.await
@@ -20,10 +20,10 @@ async fn trigger_sync_returns_provider_ids() {
#[tokio::test]
async fn trigger_sync_specific_provider() {
let (cmd, _query, _repo) = helpers::make_deps();
let (deps, _repo) = helpers::make_deps();
let ids = sync::execute(
&cmd,
&deps,
TriggerSyncCommand {
provider_id: Some("test".into()),
},
@@ -36,16 +36,15 @@ async fn trigger_sync_specific_provider() {
#[tokio::test]
async fn trigger_sync_while_running_errors() {
let (cmd, _query, repo) = helpers::make_deps();
let (deps, repo) = helpers::make_deps();
// Simulate a running sync by inserting a log entry with "running" status
repo.items.lock().unwrap(); // just verify repo is accessible
let _log_id = domain::ports::LibraryCommand::log_sync_start(&*cmd.library_command, "test")
repo.items.lock().unwrap();
let _log_id = domain::ports::LibraryCommand::log_sync_start(&*deps.library_command, "test")
.await
.unwrap();
let result = sync::execute(
&cmd,
&deps,
TriggerSyncCommand { provider_id: None },
)
.await;