refactor: group use cases into DDD bounded contexts

Flat use_cases/ (44 files) + monolithic commands.rs/queries.rs
split into diary/, movies/, watchlist/, import/, auth/, users/,
integrations/, search/, person/, federation/ — each with own
commands.rs, queries.rs, and use case modules.

Inline tests extracted to sibling tests/ dirs.

crates/application/src/diary/tests/delete_review.rs

@@ -0,0 +1,104 @@
+use std::sync::Arc;
+
+use chrono::Utc;
+
+use domain::{
+    models::{Movie, Review},
+    ports::{MovieRepository, ReviewRepository},
+    testing::{
+        FakeDiaryRepository, InMemoryMovieRepository, InMemoryReviewRepository, NoopEventPublisher,
+    },
+    value_objects::{MovieId, MovieTitle, Rating, ReleaseYear, UserId},
+};
+
+use crate::{
+    diary::commands::DeleteReviewCommand, diary::delete_review, test_helpers::TestContextBuilder,
+};
+
+fn make_movie() -> Movie {
+    Movie::new(
+        None,
+        MovieTitle::new("Terminator".into()).unwrap(),
+        ReleaseYear::new(1984).unwrap(),
+        None,
+        None,
+    )
+}
+
+fn make_review(movie_id: MovieId, user_id: UserId) -> Review {
+    Review::new(
+        movie_id,
+        user_id,
+        Rating::new(4).unwrap(),
+        None,
+        Utc::now().naive_utc(),
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_delete_review_removes_it() {
+    let movies = InMemoryMovieRepository::new();
+    let reviews = InMemoryReviewRepository::new();
+    let diary = FakeDiaryRepository::new();
+    let events = NoopEventPublisher::new();
+
+    let movie = make_movie();
+    let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
+    let review = make_review(movie.id().clone(), user_id.clone());
+
+    movies.upsert_movie(&movie).await.unwrap();
+    reviews.save_review(&review).await.unwrap();
+    diary.seed_history(movie.clone(), vec![]);
+
+    let ctx = TestContextBuilder::new()
+        .with_movies(Arc::clone(&movies) as _)
+        .with_reviews(Arc::clone(&reviews) as _)
+        .with_diary(Arc::clone(&diary) as _)
+        .with_event_publisher(Arc::clone(&events) as _)
+        .build();
+
+    delete_review::execute(
+        &ctx,
+        DeleteReviewCommand {
+            review_id: review.id().value(),
+            requesting_user_id: user_id.value(),
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(reviews.count(), 0, "review should be deleted");
+    assert!(
+        movies.get_movie_by_id(movie.id()).await.unwrap().is_none(),
+        "movie should be deleted when no reviews remain"
+    );
+}
+
+#[tokio::test]
+async fn test_delete_review_wrong_user_is_unauthorized() {
+    let reviews = InMemoryReviewRepository::new();
+
+    let movie_id = MovieId::from_uuid(uuid::Uuid::new_v4());
+    let owner_id = UserId::from_uuid(uuid::Uuid::new_v4());
+    let other_id = uuid::Uuid::new_v4();
+    let review = make_review(movie_id, owner_id);
+
+    reviews.save_review(&review).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_reviews(Arc::clone(&reviews) as _)
+        .build();
+
+    let result = delete_review::execute(
+        &ctx,
+        DeleteReviewCommand {
+            review_id: review.id().value(),
+            requesting_user_id: other_id,
+        },
+    )
+    .await;
+
+    assert!(result.is_err(), "wrong user should not be able to delete");
+    assert_eq!(reviews.count(), 1, "review should still exist");
+}

crates/application/src/diary/tests/log_review.rs

@@ -0,0 +1,111 @@
+use std::sync::Arc;
+
+use chrono::Utc;
+
+use domain::{
+    models::Movie,
+    value_objects::{MovieTitle, ReleaseYear},
+};
+
+use domain::ports::MovieRepository;
+use domain::testing::{InMemoryMovieRepository, InMemoryReviewRepository, NoopEventPublisher};
+
+use crate::{
+    diary::commands::{LogReviewCommand, MovieInput},
+    diary::log_review,
+    test_helpers::TestContextBuilder,
+};
+
+fn movie_input_manual(title: &str, year: u16) -> MovieInput {
+    MovieInput {
+        movie_id: None,
+        external_metadata_id: None,
+        manual_title: Some(title.to_string()),
+        manual_release_year: Some(year),
+        manual_director: None,
+    }
+}
+
+fn movie_input_by_id(id: uuid::Uuid) -> MovieInput {
+    MovieInput {
+        movie_id: Some(id),
+        external_metadata_id: None,
+        manual_title: None,
+        manual_release_year: None,
+        manual_director: None,
+    }
+}
+
+#[tokio::test]
+async fn test_log_review_creates_movie_and_review() {
+    let movies = InMemoryMovieRepository::new();
+    let reviews = InMemoryReviewRepository::new();
+    let events = NoopEventPublisher::new();
+    let ctx = TestContextBuilder::new()
+        .with_movies(Arc::clone(&movies) as _)
+        .with_reviews(Arc::clone(&reviews) as _)
+        .with_event_publisher(Arc::clone(&events) as _)
+        .build();
+
+    let user_id = uuid::Uuid::new_v4();
+    let cmd = LogReviewCommand {
+        user_id,
+        input: movie_input_manual("Blade Runner", 1982),
+        rating: 4,
+        comment: None,
+        watched_at: Utc::now().naive_utc(),
+    };
+
+    log_review::execute(&ctx, cmd).await.unwrap();
+
+    assert_eq!(reviews.count(), 1, "review should be saved");
+    assert!(!events.published().is_empty(), "events should be published");
+}
+
+#[tokio::test]
+async fn test_log_review_reuses_existing_movie() {
+    let movies = InMemoryMovieRepository::new();
+    let reviews = InMemoryReviewRepository::new();
+
+    let existing_movie = Movie::new(
+        None,
+        MovieTitle::new("Alien".into()).unwrap(),
+        ReleaseYear::new(1979).unwrap(),
+        None,
+        None,
+    );
+    let movie_uuid = existing_movie.id().value();
+    movies.upsert_movie(&existing_movie).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_movies(Arc::clone(&movies) as _)
+        .with_reviews(Arc::clone(&reviews) as _)
+        .build();
+
+    let cmd = LogReviewCommand {
+        user_id: uuid::Uuid::new_v4(),
+        input: movie_input_by_id(movie_uuid),
+        rating: 5,
+        comment: None,
+        watched_at: Utc::now().naive_utc(),
+    };
+
+    log_review::execute(&ctx, cmd).await.unwrap();
+
+    assert_eq!(movies.count(), 1, "no duplicate movie");
+    assert_eq!(reviews.count(), 1);
+}
+
+#[tokio::test]
+async fn test_log_review_with_invalid_rating_fails() {
+    let ctx = TestContextBuilder::new().build();
+    let cmd = LogReviewCommand {
+        user_id: uuid::Uuid::new_v4(),
+        input: movie_input_manual("Some Film", 2000),
+        rating: 6,
+        comment: None,
+        watched_at: Utc::now().naive_utc(),
+    };
+    let result = log_review::execute(&ctx, cmd).await;
+    assert!(result.is_err(), "rating > 5 should fail");
+}

crates/application/src/diary/tests/movie_resolver.rs

@@ -0,0 +1,364 @@
+use super::*;
+use crate::diary::commands::MovieInput;
+use domain::{
+    errors::DomainError,
+    models::Movie,
+    ports::{MetadataSearchCriteria, MovieRepository},
+    value_objects::{ExternalMetadataId, MovieId, MovieTitle, PosterUrl, ReleaseYear},
+};
+
+fn make_input(ext_id: Option<&str>, title: Option<&str>, year: Option<u16>) -> MovieInput {
+    MovieInput {
+        movie_id: None,
+        external_metadata_id: ext_id.map(String::from),
+        manual_title: title.map(String::from),
+        manual_release_year: year,
+        manual_director: None,
+    }
+}
+
+fn make_movie() -> Movie {
+    Movie::new(
+        None,
+        MovieTitle::new("Inception".to_string()).unwrap(),
+        ReleaseYear::new(2010).unwrap(),
+        None,
+        None,
+    )
+}
+
+struct RepoWithExternalMovie(Movie);
+struct RepoEmpty;
+struct RepoWithTitleMatch(Movie);
+
+#[async_trait::async_trait]
+impl MovieRepository for RepoWithExternalMovie {
+    async fn get_movie_by_external_id(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<Movie>, DomainError> {
+        Ok(Some(self.0.clone()))
+    }
+    async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+        panic!("unexpected")
+    }
+    async fn get_movies_by_title_and_year(
+        &self,
+        _: &MovieTitle,
+        _: &ReleaseYear,
+    ) -> Result<Vec<Movie>, DomainError> {
+        panic!("unexpected")
+    }
+    async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn list_movies(
+        &self,
+        _: &domain::models::collections::PageParams,
+        _: &domain::models::MovieFilter,
+    ) -> Result<domain::models::collections::Paginated<domain::models::MovieSummary>, DomainError>
+    {
+        panic!("unexpected")
+    }
+}
+
+#[async_trait::async_trait]
+impl MovieRepository for RepoEmpty {
+    async fn get_movie_by_external_id(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<Movie>, DomainError> {
+        Ok(None)
+    }
+    async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+        panic!("unexpected")
+    }
+    async fn get_movies_by_title_and_year(
+        &self,
+        _: &MovieTitle,
+        _: &ReleaseYear,
+    ) -> Result<Vec<Movie>, DomainError> {
+        Ok(vec![])
+    }
+    async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn list_movies(
+        &self,
+        _: &domain::models::collections::PageParams,
+        _: &domain::models::MovieFilter,
+    ) -> Result<domain::models::collections::Paginated<domain::models::MovieSummary>, DomainError>
+    {
+        panic!("unexpected")
+    }
+}
+
+#[async_trait::async_trait]
+impl MovieRepository for RepoWithTitleMatch {
+    async fn get_movie_by_external_id(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<Movie>, DomainError> {
+        panic!("unexpected")
+    }
+    async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
+        panic!("unexpected")
+    }
+    async fn get_movies_by_title_and_year(
+        &self,
+        _: &MovieTitle,
+        _: &ReleaseYear,
+    ) -> Result<Vec<Movie>, DomainError> {
+        Ok(vec![self.0.clone()])
+    }
+    async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
+        panic!("unexpected")
+    }
+    async fn list_movies(
+        &self,
+        _: &domain::models::collections::PageParams,
+        _: &domain::models::MovieFilter,
+    ) -> Result<domain::models::collections::Paginated<domain::models::MovieSummary>, DomainError>
+    {
+        panic!("unexpected")
+    }
+}
+
+struct MetaReturnsMovie(Movie);
+struct MetaErrors;
+
+#[async_trait::async_trait]
+impl MetadataClient for MetaReturnsMovie {
+    async fn fetch_movie_metadata(&self, _: &MetadataSearchCriteria) -> Result<Movie, DomainError> {
+        Ok(self.0.clone())
+    }
+    async fn get_poster_url(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<PosterUrl>, DomainError> {
+        panic!("unexpected")
+    }
+}
+
+#[async_trait::async_trait]
+impl MetadataClient for MetaErrors {
+    async fn fetch_movie_metadata(&self, _: &MetadataSearchCriteria) -> Result<Movie, DomainError> {
+        Err(DomainError::InfrastructureError(
+            "metadata unavailable".into(),
+        ))
+    }
+    async fn get_poster_url(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<PosterUrl>, DomainError> {
+        panic!("unexpected")
+    }
+}
+
+// --- ExternalIdStrategy ---
+
+#[test]
+fn external_id_strategy_can_handle_cmd_with_id() {
+    let input = make_input(Some("tt123"), None, None);
+    assert!(ExternalIdStrategy.can_handle(&input));
+}
+
+#[test]
+fn external_id_strategy_cannot_handle_cmd_without_id() {
+    let input = make_input(None, Some("Inception"), Some(2010));
+    assert!(!ExternalIdStrategy.can_handle(&input));
+}
+
+#[tokio::test]
+async fn external_id_strategy_returns_cached_movie() {
+    let movie = make_movie();
+    let repo = RepoWithExternalMovie(movie.clone());
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(Some("tt123"), None, None);
+    let result = ExternalIdStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(matches!(result, Some((_, false))));
+}
+
+#[tokio::test]
+async fn external_id_strategy_fetches_from_metadata_when_not_cached() {
+    let movie = make_movie();
+    let repo = RepoEmpty;
+    let meta = MetaReturnsMovie(movie);
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(Some("tt123"), None, None);
+    let result = ExternalIdStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(matches!(result, Some((_, true))));
+}
+
+#[tokio::test]
+async fn external_id_strategy_falls_through_on_metadata_error() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(Some("tt123"), None, None);
+    let result = ExternalIdStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(result.is_none());
+}
+
+// --- TitleSearchStrategy ---
+
+#[test]
+fn title_strategy_can_handle_cmd_with_title() {
+    let input = make_input(None, Some("Inception"), Some(2010));
+    assert!(TitleSearchStrategy.can_handle(&input));
+}
+
+#[test]
+fn title_strategy_cannot_handle_cmd_without_title() {
+    let input = make_input(Some("tt123"), None, None);
+    assert!(!TitleSearchStrategy.can_handle(&input));
+}
+
+#[tokio::test]
+async fn title_strategy_fetches_from_metadata() {
+    let movie = make_movie();
+    let repo = RepoEmpty;
+    let meta = MetaReturnsMovie(movie);
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, Some("Inception"), Some(2010));
+    let result = TitleSearchStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(matches!(result, Some((_, true))));
+}
+
+#[tokio::test]
+async fn title_strategy_falls_through_on_metadata_error() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, Some("Inception"), Some(2010));
+    let result = TitleSearchStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(result.is_none());
+}
+
+// --- ManualMovieStrategy ---
+
+#[test]
+fn manual_strategy_can_handle_cmd_with_title() {
+    let input = make_input(None, Some("Inception"), Some(2010));
+    assert!(ManualMovieStrategy.can_handle(&input));
+}
+
+#[test]
+fn manual_strategy_cannot_handle_cmd_without_title() {
+    let input = make_input(Some("tt123"), None, None);
+    assert!(!ManualMovieStrategy.can_handle(&input));
+}
+
+#[tokio::test]
+async fn manual_strategy_returns_existing_movie() {
+    let movie = make_movie();
+    let repo = RepoWithTitleMatch(movie.clone());
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, Some("Inception"), Some(2010));
+    let result = ManualMovieStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(matches!(result, Some((_, false))));
+}
+
+#[tokio::test]
+async fn manual_strategy_creates_new_movie_when_no_match() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, Some("Inception"), Some(2010));
+    let result = ManualMovieStrategy.resolve(&input, &deps).await.unwrap();
+    assert!(matches!(result, Some((_, true))));
+}
+
+#[tokio::test]
+async fn manual_strategy_errors_without_year() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, Some("Inception"), None);
+    assert!(ManualMovieStrategy.resolve(&input, &deps).await.is_err());
+}
+
+// --- MovieResolver pipeline ---
+
+#[tokio::test]
+async fn resolver_returns_error_when_no_strategy_matches() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(None, None, None);
+    let result = MovieResolver::default_pipeline()
+        .resolve(&input, &deps)
+        .await;
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn resolver_uses_cached_movie_when_external_id_matches() {
+    let movie = make_movie();
+    let repo = RepoWithExternalMovie(movie.clone());
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(Some("tt123"), None, None);
+    let (_, is_new) = MovieResolver::default_pipeline()
+        .resolve(&input, &deps)
+        .await
+        .unwrap();
+    assert!(!is_new);
+}
+
+#[tokio::test]
+async fn resolver_falls_through_to_manual_when_external_and_title_both_fail() {
+    let repo = RepoEmpty;
+    let meta = MetaErrors;
+    let deps = MovieResolverDeps {
+        repository: &repo,
+        metadata_client: &meta,
+    };
+    let input = make_input(Some("tt123"), Some("Inception"), Some(2010));
+    let (_, is_new) = MovieResolver::default_pipeline()
+        .resolve(&input, &deps)
+        .await
+        .unwrap();
+    assert!(is_new);
+}