GKaszewski/movies-diary
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: atomic wrapup, movie, integration writes

Browse Source 
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).
This commit is contained in:
Gabriel Kaszewski
2026-10-26 01:02:34 +01:00
parent 2f133afb96
commit 6c295866a0
51 changed files with 1281 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
crates/adapters/sqlite/src/repositories/movie/command.rs
View File

@@ -1,11 +1,15 @@
use async_trait::async_trait;
use domain::{errors::DomainError, models::Movie, ports::MovieCommand, value_objects::MovieId};
use domain::{
errors::DomainError, events::DomainEvent, models::Movie, ports::MovieCommand,
value_objects::MovieId,
};
use super::SqliteMovieRepository;
use crate::shared::enqueue_events;
#[async_trait]
impl MovieCommand for SqliteMovieRepository {
async fn upsert_movie(&self, movie: &Movie) -> Result<(), DomainError> {
async fn upsert_movie(&self, movie: &Movie, events: &[DomainEvent]) -> Result<(), DomainError> {
let id = movie.id().value().to_string();
let external_metadata_id = movie.external_metadata_id().map(|e| e.value().to_string());
let title = movie.title().value();
@@ -13,6 +17,11 @@ impl MovieCommand for SqliteMovieRepository {
let director = movie.director();
let poster_path = movie.poster_path().map(|p| p.value().to_string());
let mut tx = self
.pool
.begin()
.await
.map_err(crate::shared::map_sqlx_error)?;
sqlx::query(
"INSERT INTO movies (id, external_metadata_id, title, release_year, director, poster_path)
VALUES (?, ?, ?, ?, ?, ?)
@@ -29,20 +38,32 @@ impl MovieCommand for SqliteMovieRepository {
.bind(release_year)
.bind(director)
.bind(&poster_path)
.execute(&self.pool)
.execute(&mut *tx)
.await
.map_err(crate::shared::map_sqlx_error)?;
Ok(())
enqueue_events(&mut tx, events).await?;
tx.commit().await.map_err(crate::shared::map_sqlx_error)
}
async fn delete_movie(&self, movie_id: &MovieId) -> Result<(), DomainError> {
async fn delete_movie(
&self,
movie_id: &MovieId,
events: &[DomainEvent],
) -> Result<(), DomainError> {
let id = movie_id.value().to_string();
sqlx::query("DELETE FROM movies WHERE id = ?")
.bind(&id)
.execute(&self.pool)
let mut tx = self
.pool
.begin()
.await
.map_err(crate::shared::map_sqlx_error)?;
Ok(())
let result = sqlx::query("DELETE FROM movies WHERE id = ?")
.bind(&id)
.execute(&mut *tx)
.await
.map_err(crate::shared::map_sqlx_error)?;
if result.rows_affected() > 0 {
enqueue_events(&mut tx, events).await?;
}
tx.commit().await.map_err(crate::shared::map_sqlx_error)
}
}

16
crates/adapters/sqlite/src/repositories/watch_event/command.rs
View File

@@ -1,18 +1,19 @@
use async_trait::async_trait;
use domain::{
errors::DomainError,
events::DomainEvent,
models::{WatchEvent, WatchEventStatus},
ports::WatchEventCommand,
value_objects::WatchEventId,
};
use crate::shared::datetime_to_str;
use crate::shared::{datetime_to_str, enqueue_events};
use super::SqliteWatchEventRepository;
#[async_trait]
impl WatchEventCommand for SqliteWatchEventRepository {
async fn save(&self, event: &WatchEvent) -> Result<(), DomainError> {
async fn save(&self, event: &WatchEvent, events: &[DomainEvent]) -> Result<(), DomainError> {
let id = event.id().value().to_string();
let user_id = event.user_id().value().to_string();
let movie_id = event.movie_id().map(|m| m.value().to_string());
@@ -21,6 +22,11 @@ impl WatchEventCommand for SqliteWatchEventRepository {
let status = event.status().to_string();
let created_at = datetime_to_str(event.created_at());
let mut tx = self
.pool
.begin()
.await
.map_err(crate::shared::map_sqlx_error)?;
sqlx::query(
"INSERT INTO watch_events \
(id, user_id, movie_id, title, year, external_metadata_id, source, watched_at, status, created_at) \
@@ -36,11 +42,11 @@ impl WatchEventCommand for SqliteWatchEventRepository {
.bind(&watched_at)
.bind(&status)
.bind(&created_at)
.execute(&self.pool)
.execute(&mut *tx)
.await
.map_err(crate::shared::map_sqlx_error)?;
Ok(())
enqueue_events(&mut tx, events).await?;
tx.commit().await.map_err(crate::shared::map_sqlx_error)
}
async fn update_status(

42
crates/adapters/sqlite/src/repositories/wrapup/mod.rs
View File

@@ -2,6 +2,7 @@ use async_trait::async_trait;
use chrono::NaiveDate;
use domain::{
errors::DomainError,
events::DomainEvent,
models::wrapup::{WrapUpRecord, WrapUpReport, WrapUpStatus},
ports::WrapUpRepository,
value_objects::WrapUpId,
@@ -9,6 +10,7 @@ use domain::{
use sqlx::SqlitePool;
use uuid::Uuid;
use crate::shared::enqueue_events;
use rows::{row_to_record, status_to_str};
mod query;
@@ -30,7 +32,11 @@ impl SqliteWrapUpRepository {
#[async_trait]
impl WrapUpRepository for SqliteWrapUpRepository {
async fn create(&self, record: &WrapUpRecord) -> Result<(), DomainError> {
async fn create(
&self,
record: &WrapUpRecord,
events: &[DomainEvent],
) -> Result<(), DomainError> {
let id = record.id.value().to_string();
let user_id = record.user_id.map(|u| u.to_string());
let status = status_to_str(&record.status);
@@ -41,6 +47,11 @@ impl WrapUpRepository for SqliteWrapUpRepository {
.completed_at
.map(|dt| dt.format("%Y-%m-%d %H:%M:%S").to_string());
let mut tx = self
.pool
.begin()
.await
.map_err(crate::shared::map_sqlx_error)?;
sqlx::query(
"INSERT INTO wrap_up_records \
(id, user_id, start_date, end_date, status, report_json, error_message, created_at, completed_at) \
@@ -55,11 +66,11 @@ impl WrapUpRepository for SqliteWrapUpRepository {
.bind(&record.error_message)
.bind(&created)
.bind(&completed)
.execute(&self.pool)
.execute(&mut *tx)
.await
.map_err(crate::shared::map_sqlx_error)?;
Ok(())
enqueue_events(&mut tx, events).await?;
tx.commit().await.map_err(crate::shared::map_sqlx_error)
}
async fn update_status(
@@ -82,23 +93,36 @@ impl WrapUpRepository for SqliteWrapUpRepository {
Ok(())
}
async fn set_complete(&self, id: &WrapUpId, report: &WrapUpReport) -> Result<(), DomainError> {
async fn set_complete(
&self,
id: &WrapUpId,
report: &WrapUpReport,
events: &[DomainEvent],
) -> Result<(), DomainError> {
let id_str = id.value().to_string();
let json = serde_json::to_string(report)
.map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
sqlx::query(
let mut tx = self
.pool
.begin()
.await
.map_err(crate::shared::map_sqlx_error)?;
let result = sqlx::query(
"UPDATE wrap_up_records \
SET status = 'ready', report_json = ?, completed_at = strftime('%Y-%m-%d %H:%M:%S', 'now') \
WHERE id = ?",
)
.bind(&json)
.bind(&id_str)
.execute(&self.pool)
.execute(&mut *tx)
.await
.map_err(crate::shared::map_sqlx_error)?;
Ok(())
if result.rows_affected() == 0 {
return Err(DomainError::NotFound("wrapup record".into()));
}
enqueue_events(&mut tx, events).await?;
tx.commit().await.map_err(crate::shared::map_sqlx_error)
}
async fn get_by_id(&self, id: &WrapUpId) -> Result<Option<WrapUpRecord>, DomainError> {

56
crates/adapters/sqlite/tests/cascade_test.rs
View File

@@ -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,

297
crates/adapters/sqlite/tests/repositories/outbox_writes_test.rs
View File

@@ -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);
}

4
crates/adapters/sqlite/tests/repositories/review_repository_test.rs
View File

@@ -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);