fix: NewRemoteReview param struct, atomic review+orphan movie delete

crates/adapters/sqlite/src/repositories/review/mod.rs

@@ -4,7 +4,7 @@ use domain::{
     events::DomainEvent,
     models::{Review, ReviewSource},
     ports::ReviewRepository,
-    value_objects::{ReviewId, UserId},
+    value_objects::{MovieId, ReviewId, UserId},
 };
 use sqlx::SqlitePool;
 
@@ -114,12 +114,15 @@ impl ReviewRepository for SqliteReviewRepository {
         tx.commit().await.map_err(crate::shared::map_sqlx_error)
     }
 
-    async fn delete_review(
+    async fn delete_review_and_orphaned_movie(
         &self,
         review_id: &ReviewId,
-        events: &[DomainEvent],
+        movie_id: &MovieId,
+        review_events: &[DomainEvent],
+        orphan_events: &[DomainEvent],
     ) -> Result<(), DomainError> {
         let id = review_id.value().to_string();
+        let movie = movie_id.value().to_string();
         let mut tx = self
             .pool
             .begin()
@@ -130,7 +133,19 @@ impl ReviewRepository for SqliteReviewRepository {
             .execute(&mut *tx)
             .await
             .map_err(crate::shared::map_sqlx_error)?;
-        enqueue_events(&mut tx, events).await?;
+        enqueue_events(&mut tx, review_events).await?;
+        let orphaned = sqlx::query(
+            "DELETE FROM movies WHERE id = ? \
+             AND NOT EXISTS (SELECT 1 FROM reviews WHERE movie_id = ?)",
+        )
+        .bind(&movie)
+        .bind(&movie)
+        .execute(&mut *tx)
+        .await
+        .map_err(crate::shared::map_sqlx_error)?;
+        if orphaned.rows_affected() > 0 {
+            enqueue_events(&mut tx, orphan_events).await?;
+        }
         tx.commit().await.map_err(crate::shared::map_sqlx_error)
     }
 

crates/adapters/sqlite/tests/repositories/review_repository_test.rs

@@ -135,36 +135,85 @@ async fn a_failing_enqueue_after_the_review_update_rolls_the_update_back() {
     assert_eq!(count(&pool, "event_queue").await, 0);
 }
 
+fn deleted(review: &domain::models::Review) -> DomainEvent {
+    DomainEvent::ReviewDeleted {
+        review_id: review.id().clone(),
+        user_id: review.user_id().clone(),
+    }
+}
+
+fn movie_deleted(review: &domain::models::Review) -> DomainEvent {
+    DomainEvent::MovieDeleted {
+        movie_id: review.movie_id().clone(),
+        poster_path: None,
+    }
+}
+
 #[tokio::test]
-async fn deleting_a_review_writes_the_removal_and_its_event_in_one_commit() {
+async fn deleting_the_last_review_removes_the_movie_and_enqueues_both_events_in_one_commit() {
     let (pool, review) = seeded().await;
     let repo = SqliteReviewRepository::new(pool.clone());
     repo.save_review(&review, &[]).await.unwrap();
-    let event = DomainEvent::ReviewDeleted {
-        review_id: review.id().clone(),
-        user_id: review.user_id().clone(),
-    };
 
-    repo.delete_review(review.id(), &[event]).await.unwrap();
+    repo.delete_review_and_orphaned_movie(
+        review.id(),
+        review.movie_id(),
+        &[deleted(&review)],
+        &[movie_deleted(&review)],
+    )
+    .await
+    .unwrap();
 
     assert_eq!(count(&pool, "reviews").await, 0);
+    assert_eq!(count(&pool, "movies").await, 0);
+    assert_eq!(count(&pool, "event_queue").await, 2);
+}
+
+#[tokio::test]
+async fn deleting_a_review_while_another_remains_keeps_the_movie_and_enqueues_only_review_deleted()
+{
+    let (pool, review) = seeded().await;
+    let repo = SqliteReviewRepository::new(pool.clone());
+    repo.save_review(&review, &[]).await.unwrap();
+    let other = test_review(review.movie_id(), review.user_id(), 3);
+    repo.save_review(&other, &[]).await.unwrap();
+
+    repo.delete_review_and_orphaned_movie(
+        review.id(),
+        review.movie_id(),
+        &[deleted(&review)],
+        &[movie_deleted(&review)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(count(&pool, "reviews").await, 1);
+    assert_eq!(count(&pool, "movies").await, 1);
     assert_eq!(count(&pool, "event_queue").await, 1);
 }
 
 #[tokio::test]
-async fn a_failing_enqueue_after_the_review_delete_rolls_the_delete_back() {
+async fn a_failing_enqueue_rolls_back_the_review_and_movie_delete() {
     let (pool, review) = seeded().await;
     let repo = SqliteReviewRepository::new(pool.clone());
     repo.save_review(&review, &[]).await.unwrap();
     fail_event_inserts(&pool).await;
-    let event = DomainEvent::ReviewDeleted {
-        review_id: review.id().clone(),
-        user_id: review.user_id().clone(),
-    };
 
-    let result = repo.delete_review(review.id(), &[event]).await;
+    let result = repo
+        .delete_review_and_orphaned_movie(
+            review.id(),
+            review.movie_id(),
+            &[deleted(&review)],
+            &[movie_deleted(&review)],
+        )
+        .await;
 
     assert!(result.is_err());
-    assert_eq!(count(&pool, "reviews").await, 1, "delete rolled back");
+    assert_eq!(
+        count(&pool, "reviews").await,
+        1,
+        "review delete rolled back"
+    );
+    assert_eq!(count(&pool, "movies").await, 1, "movie delete rolled back");
     assert_eq!(count(&pool, "event_queue").await, 0);
 }