feat: atomic wrapup, movie, integration writes

Ride writes: WrapUpRequested/Completed (wrapup create/set_complete),
MovieDiscovered (resolve upsert, new+ext id only), PosterSynced (poster
handler upsert), MovieDeleted (delete_movie), WatchEventIngested (save).
Deps drop event_publisher: wrapup, ingest, delete_review, watchlist add,
review logger.

Remaining .publish( sites:
announce-only: users/delete_account UserDeleted, person/get +
get_credits PersonEnrichmentRequested, jobs/enrichment_staleness,
http-axum search, movies/sync_poster + poster_sync_handler +
image-converter backfill + users/update_profile ImageStored (object
storage), activitypub federation_event_bridge (reacting to events).
rides write, deferred: social/execute (see report),
activitypub review_handler MovieEnrichmentRequested (after
save_remote_review).

crates/adapters/sqlite/tests/cascade_test.rs

@@ -124,7 +124,7 @@ async fn seed_user_with_dependents(
     let user_id = user.id().clone();
     let movie = test_movie("Heat");
     parts.user.save(&user).await.unwrap();
-    parts.movie_command.upsert_movie(&movie).await.unwrap();
+    parts.movie_command.upsert_movie(&movie, &[]).await.unwrap();
 
     parts
         .watchlist
@@ -165,15 +165,18 @@ async fn seed_user_with_dependents(
         .await
         .unwrap();
     SqliteWatchEventRepository::new(pool.clone())
-        .save(&WatchEvent::new(
-            user_id.clone(),
-            "Heat".into(),
-            Some(1995),
-            None,
-            WatchEventSource::Jellyfin,
-            test_watched_at(),
-            None,
-        ))
+        .save(
+            &WatchEvent::new(
+                user_id.clone(),
+                "Heat".into(),
+                Some(1995),
+                None,
+                WatchEventSource::Jellyfin,
+                test_watched_at(),
+                None,
+            ),
+            &[],
+        )
         .await
         .unwrap();
     let social = SqliteSocialRepository::new(
@@ -257,7 +260,7 @@ async fn deleting_a_movie_cascades_to_watchlist_entries_and_every_enrichment_tab
     let user = test_user("alice");
     let movie = test_movie("Heat");
     parts.user.save(&user).await.unwrap();
-    parts.movie_command.upsert_movie(&movie).await.unwrap();
+    parts.movie_command.upsert_movie(&movie, &[]).await.unwrap();
     parts
         .watchlist
         .add(
@@ -272,22 +275,29 @@ async fn deleting_a_movie_cascades_to_watchlist_entries_and_every_enrichment_tab
         .await
         .unwrap();
     SqliteWatchEventRepository::new(pool.clone())
-        .save(&WatchEvent::new(
-            user.id().clone(),
-            "Heat".into(),
-            Some(1995),
-            None,
-            WatchEventSource::Plex,
-            test_watched_at(),
-            Some(movie.id().clone()),
-        ))
+        .save(
+            &WatchEvent::new(
+                user.id().clone(),
+                "Heat".into(),
+                Some(1995),
+                None,
+                WatchEventSource::Plex,
+                test_watched_at(),
+                Some(movie.id().clone()),
+            ),
+            &[],
+        )
         .await
         .unwrap();
     for table in MOVIE_CASCADE_TABLES {
         assert!(count(&pool, table).await > 0, "{table} should be seeded");
     }
 
-    parts.movie_command.delete_movie(movie.id()).await.unwrap();
+    parts
+        .movie_command
+        .delete_movie(movie.id(), &[])
+        .await
+        .unwrap();
 
     for table in MOVIE_CASCADE_TABLES {
         assert_eq!(count(&pool, table).await, 0, "{table} should cascade");
@@ -306,14 +316,14 @@ async fn deleting_a_movie_that_has_reviews_is_refused_because_reviews_do_not_cas
     let user = test_user("alice");
     let movie = test_movie("Heat");
     parts.user.save(&user).await.unwrap();
-    parts.movie_command.upsert_movie(&movie).await.unwrap();
+    parts.movie_command.upsert_movie(&movie, &[]).await.unwrap();
     parts
         .review
         .save_review(&test_review(movie.id(), user.id(), 5), &[])
         .await
         .unwrap();
 
-    let result = parts.movie_command.delete_movie(movie.id()).await;
+    let result = parts.movie_command.delete_movie(movie.id(), &[]).await;
 
     assert!(matches!(
         result,

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

@@ -4,7 +4,8 @@ use domain::{
     events::DomainEvent,
     models::{ProfileField, UserProfile, WatchlistEntry},
     ports::{
-        GoalCommand, MovieCommand, UserProfileFieldsRepository, UserRepository, WatchlistRepository,
+        GoalCommand, MovieCommand, UserProfileFieldsRepository, UserRepository, WatchEventCommand,
+        WatchlistRepository, WrapUpRepository,
     },
     testing::{test_goal, test_movie, test_user},
     value_objects::UserId,
@@ -161,7 +162,7 @@ async fn watchlist_fixture() -> (SqlitePool, UserId, domain::models::Movie) {
     let (pool, user) = pool_with_user().await;
     let movie = test_movie("Heat");
     SqliteMovieRepository::new(pool.clone())
-        .upsert_movie(&movie)
+        .upsert_movie(&movie, &[])
         .await
         .unwrap();
     (pool, user.id().clone(), movie)
@@ -419,3 +420,295 @@ async fn a_failing_enqueue_rolls_back_the_profile_fields_replacement() {
         "delete of the old fields rolled back"
     );
 }
+
+fn movie_discovered(movie: &domain::models::Movie) -> DomainEvent {
+    DomainEvent::MovieDiscovered {
+        movie_id: movie.id().clone(),
+        external_metadata_id: domain::value_objects::ExternalMetadataId::new("tmdb:1".into())
+            .unwrap(),
+    }
+}
+
+fn movie_deleted(movie: &domain::models::Movie) -> DomainEvent {
+    DomainEvent::MovieDeleted {
+        movie_id: movie.id().clone(),
+        poster_path: None,
+    }
+}
+
+#[tokio::test]
+async fn upserting_a_movie_writes_the_movie_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+
+    SqliteMovieRepository::new(pool.clone())
+        .upsert_movie(&movie, &[movie_discovered(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "movies").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_movie_upsert_of_a_new_movie() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+    fail_event_inserts(&pool).await;
+
+    let result = SqliteMovieRepository::new(pool.clone())
+        .upsert_movie(&movie, &[movie_discovered(&movie)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "movies").await, 0);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_a_movie_update() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let mut movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+    movie.update_poster(domain::value_objects::PosterPath::new("posters/new.jpg".into()).unwrap());
+    fail_event_inserts(&pool).await;
+
+    let result = repo.upsert_movie(&movie, &[movie_discovered(&movie)]).await;
+
+    assert!(result.is_err());
+    let poster: Option<String> = sqlx::query_scalar("SELECT poster_path FROM movies")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(poster, None, "poster update rolled back");
+}
+
+#[tokio::test]
+async fn deleting_a_movie_writes_the_removal_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+
+    repo.delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "movies").await, 0);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_movie_delete() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+    fail_event_inserts(&pool).await;
+
+    let result = repo
+        .delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "movies").await, 1, "delete rolled back");
+}
+
+#[tokio::test]
+async fn deleting_an_absent_movie_enqueues_no_event() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+
+    SqliteMovieRepository::new(pool.clone())
+        .delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "event_queue").await, 0);
+}
+
+fn wrapup_record(user_id: Option<uuid::Uuid>) -> domain::models::wrapup::WrapUpRecord {
+    use domain::models::wrapup::WrapUpStatus;
+    domain::models::wrapup::WrapUpRecord {
+        id: domain::value_objects::WrapUpId::generate(),
+        user_id,
+        start_date: chrono::NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        end_date: chrono::NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+        status: WrapUpStatus::Pending,
+        report: None,
+        error_message: None,
+        created_at: chrono::Utc::now().naive_utc(),
+        completed_at: None,
+    }
+}
+
+fn wrapup_requested(record: &domain::models::wrapup::WrapUpRecord) -> DomainEvent {
+    DomainEvent::WrapUpRequested {
+        wrapup_id: record.id.clone(),
+        user_id: None,
+        start_date: record.start_date,
+        end_date: record.end_date,
+    }
+}
+
+fn wrapup_completed(record: &domain::models::wrapup::WrapUpRecord) -> DomainEvent {
+    DomainEvent::WrapUpCompleted {
+        wrapup_id: record.id.clone(),
+    }
+}
+
+fn empty_report() -> domain::models::wrapup::WrapUpReport {
+    serde_json::from_value(serde_json::json!({
+        "scope": "Global",
+        "date_range": { "start": "2024-01-01", "end": "2024-12-31" },
+        "generated_at": "2025-01-01T00:00:00Z",
+        "total_movies": 0,
+        "total_watch_time_minutes": 0,
+        "movies_per_month": [],
+        "rating_distribution": [0, 0, 0, 0, 0],
+        "top_directors": [],
+        "top_actors": [],
+        "director_diversity": 0,
+        "actor_diversity": 0,
+        "top_genres": [],
+        "genre_diversity": 0,
+        "top_keywords": [],
+        "language_distribution": [],
+        "watch_medium_distribution": [],
+        "total_rewatches": 0,
+        "poster_paths": [],
+        "top_cast_profile_paths": [],
+    }))
+    .expect("minimal wrap-up report")
+}
+
+#[tokio::test]
+async fn creating_a_wrapup_writes_the_record_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+
+    sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .create(&record, &[wrapup_requested(&record)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "wrap_up_records").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_wrapup_create() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+    fail_event_inserts(&pool).await;
+
+    let result = sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .create(&record, &[wrapup_requested(&record)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "wrap_up_records").await, 0);
+}
+
+#[tokio::test]
+async fn completing_a_wrapup_writes_the_report_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let repo = sqlite::SqliteWrapUpRepository::new(pool.clone());
+    let record = wrapup_record(None);
+    repo.create(&record, &[]).await.unwrap();
+
+    repo.set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await
+        .unwrap();
+
+    let status: String = sqlx::query_scalar("SELECT status FROM wrap_up_records")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(status, "ready");
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_wrapup_completion() {
+    let pool = migrated_pool().await;
+    let repo = sqlite::SqliteWrapUpRepository::new(pool.clone());
+    let record = wrapup_record(None);
+    repo.create(&record, &[]).await.unwrap();
+    fail_event_inserts(&pool).await;
+
+    let result = repo
+        .set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await;
+
+    assert!(result.is_err());
+    let status: String = sqlx::query_scalar("SELECT status FROM wrap_up_records")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(status, "pending", "completion rolled back");
+}
+
+#[tokio::test]
+async fn completing_a_missing_wrapup_is_not_found_and_enqueues_no_event() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+
+    let result = sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await;
+
+    assert!(matches!(
+        result,
+        Err(domain::errors::DomainError::NotFound(_))
+    ));
+    assert_eq!(count(&pool, "event_queue").await, 0);
+}
+
+fn watch_event_for(user_id: &UserId) -> domain::models::WatchEvent {
+    domain::models::WatchEvent::new(
+        user_id.clone(),
+        "Heat".into(),
+        Some(1995),
+        None,
+        domain::models::WatchEventSource::Jellyfin,
+        chrono::Utc::now().naive_utc(),
+        None,
+    )
+}
+
+fn watch_event_ingested(user_id: &UserId) -> DomainEvent {
+    DomainEvent::WatchEventIngested {
+        user_id: user_id.clone(),
+        title: "Heat".into(),
+        source: "jellyfin".into(),
+    }
+}
+
+#[tokio::test]
+async fn saving_a_watch_event_writes_the_row_and_its_event_in_one_commit() {
+    let (pool, user) = pool_with_user().await;
+    let event = watch_event_for(user.id());
+
+    sqlite::SqliteWatchEventRepository::new(pool.clone())
+        .save(&event, &[watch_event_ingested(user.id())])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "watch_events").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_watch_event_save() {
+    let (pool, user) = pool_with_user().await;
+    let event = watch_event_for(user.id());
+    fail_event_inserts(&pool).await;
+
+    let result = sqlite::SqliteWatchEventRepository::new(pool.clone())
+        .save(&event, &[watch_event_ingested(user.id())])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "watch_events").await, 0);
+}

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

@@ -28,7 +28,7 @@ async fn saving_a_review_writes_the_review_and_its_event_in_one_commit() {
         .await
         .unwrap();
     SqliteMovieRepository::new(pool.clone())
-        .upsert_movie(&movie)
+        .upsert_movie(&movie, &[])
         .await
         .unwrap();
     let review = test_review(movie.id(), user.id(), 4);
@@ -79,7 +79,7 @@ async fn seeded() -> (SqlitePool, domain::models::Review) {
         .await
         .unwrap();
     SqliteMovieRepository::new(pool.clone())
-        .upsert_movie(&movie)
+        .upsert_movie(&movie, &[])
         .await
         .unwrap();
     let review = test_review(movie.id(), user.id(), 4);