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> {