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

refactor(wrapup): scoped deps — HandleWrapUpRequestedDeps, flat-Arc jobs

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-06-11 22:29:30 +02:00
parent cdff0de53d
commit ddf100cfc2
18 changed files with 185 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
crates/application/src/wrapup/compute.rs
View File

@@ -1,16 +1,16 @@
use crate::context::AppContext;
use std::sync::Arc;
use crate::wrapup::queries::ComputeWrapUpQuery;
use domain::errors::DomainError;
use domain::models::wrapup::WrapUpReport;
use domain::ports::WrapUpStatsQuery;
use domain::services::wrapup_analyzer;
pub async fn execute(
ctx: &AppContext,
wrapup_stats: Arc<dyn WrapUpStatsQuery>,
query: ComputeWrapUpQuery,
) -> Result<WrapUpReport, DomainError> {
let rows = ctx
.repos
.wrapup_stats
let rows = wrapup_stats
.get_reviews_with_profiles(&query.scope, &query.date_range)
.await?;
Ok(wrapup_analyzer::build_report(

15
crates/application/src/wrapup/delete.rs
View File

@@ -1,16 +1,19 @@
use std::sync::Arc;
use domain::errors::DomainError;
use domain::ports::WrapUpRepository;
use domain::value_objects::WrapUpId;
use crate::context::AppContext;
pub async fn execute(ctx: &AppContext, id: WrapUpId) -> Result<(), DomainError> {
ctx.repos
.wrapup_repo
pub async fn execute(
wrapup_repo: Arc<dyn WrapUpRepository>,
id: WrapUpId,
) -> Result<(), DomainError> {
wrapup_repo
.get_by_id(&id)
.await?
.ok_or_else(|| DomainError::NotFound("wrap-up not found".into()))?;
ctx.repos.wrapup_repo.delete(&id).await
wrapup_repo.delete(&id).await
}
#[cfg(test)]

9
crates/application/src/wrapup/deps.rs Normal file
View File

@@ -0,0 +1,9 @@
use std::sync::Arc;
use domain::ports::{EventPublisher, WrapUpRepository, WrapUpStatsQuery};
pub struct HandleWrapUpRequestedDeps {
pub wrapup_repo: Arc<dyn WrapUpRepository>,
pub event_publisher: Arc<dyn EventPublisher>,
pub wrapup_stats: Arc<dyn WrapUpStatsQuery>,
}

20
crates/application/src/wrapup/event_handler.rs
View File

@@ -3,20 +3,28 @@ use std::sync::Arc;
use async_trait::async_trait;
use domain::errors::DomainError;
use domain::events::DomainEvent;
use domain::ports::EventHandler;
use domain::ports::{EventHandler, EventPublisher, WrapUpRepository, WrapUpStatsQuery};
use tokio::sync::Semaphore;
use crate::context::AppContext;
use super::deps::HandleWrapUpRequestedDeps;
pub struct WrapUpEventHandler {
ctx: AppContext,
deps: HandleWrapUpRequestedDeps,
semaphore: Arc<Semaphore>,
}
impl WrapUpEventHandler {
pub fn new(ctx: AppContext) -> Self {
pub fn new(
wrapup_repo: Arc<dyn WrapUpRepository>,
event_publisher: Arc<dyn EventPublisher>,
wrapup_stats: Arc<dyn WrapUpStatsQuery>,
) -> Self {
Self {
ctx,
deps: HandleWrapUpRequestedDeps {
wrapup_repo,
event_publisher,
wrapup_stats,
},
semaphore: Arc::new(Semaphore::new(2)),
}
}
@@ -36,7 +44,7 @@ impl EventHandler for WrapUpEventHandler {
DomainError::InfrastructureError("render semaphore closed".into())
})?;
super::handle_requested::execute(
&self.ctx,
&self.deps,
wrapup_id.clone(),
user_id.as_ref().map(|u| u.value()),
*start_date,

21
crates/application/src/wrapup/generate.rs
View File

@@ -1,13 +1,19 @@
use std::sync::Arc;
use chrono::Utc;
use domain::errors::DomainError;
use domain::events::DomainEvent;
use domain::models::wrapup::{DateRange, WrapUpStatus};
use domain::ports::{EventPublisher, WrapUpRepository};
use domain::value_objects::{UserId, WrapUpId};
use crate::context::AppContext;
use crate::wrapup::commands::RequestWrapUpCommand;
pub async fn execute(ctx: &AppContext, cmd: RequestWrapUpCommand) -> Result<WrapUpId, DomainError> {
pub async fn execute(
wrapup_repo: Arc<dyn WrapUpRepository>,
event_publisher: Arc<dyn EventPublisher>,
cmd: RequestWrapUpCommand,
) -> Result<WrapUpId, DomainError> {
let date_range = DateRange::new(cmd.start_date, cmd.end_date)?;
if cmd.end_date > Utc::now().date_naive() {
@@ -16,9 +22,7 @@ pub async fn execute(ctx: &AppContext, cmd: RequestWrapUpCommand) -> Result<Wrap
));
}
let existing = ctx
.repos
.wrapup_repo
let existing = wrapup_repo
.find_existing(cmd.user_id, date_range.start(), date_range.end())
.await?;
@@ -26,7 +30,7 @@ pub async fn execute(ctx: &AppContext, cmd: RequestWrapUpCommand) -> Result<Wrap
match rec.status {
WrapUpStatus::Ready | WrapUpStatus::Generating => return Ok(rec.id.clone()),
WrapUpStatus::Failed => {
ctx.repos.wrapup_repo.delete(&rec.id).await?;
wrapup_repo.delete(&rec.id).await?;
}
WrapUpStatus::Pending => return Ok(rec.id.clone()),
}
@@ -44,10 +48,9 @@ pub async fn execute(ctx: &AppContext, cmd: RequestWrapUpCommand) -> Result<Wrap
created_at: Utc::now().naive_utc(),
completed_at: None,
};
ctx.repos.wrapup_repo.create(&record).await?;
wrapup_repo.create(&record).await?;
ctx.services
.event_publisher
event_publisher
.publish(&DomainEvent::WrapUpRequested {
wrapup_id: id.clone(),
user_id: cmd.user_id.map(UserId::from_uuid),

12
crates/application/src/wrapup/get_wrapup.rs
View File

@@ -1,11 +1,15 @@
use std::sync::Arc;
use domain::errors::DomainError;
use domain::models::wrapup::WrapUpRecord;
use domain::ports::WrapUpRepository;
use domain::value_objects::WrapUpId;
use crate::context::AppContext;
pub async fn execute(ctx: &AppContext, id: WrapUpId) -> Result<Option<WrapUpRecord>, DomainError> {
ctx.repos.wrapup_repo.get_by_id(&id).await
pub async fn execute(
wrapup_repo: Arc<dyn WrapUpRepository>,
id: WrapUpId,
) -> Result<Option<WrapUpRecord>, DomainError> {
wrapup_repo.get_by_id(&id).await
}
#[cfg(test)]

21
crates/application/src/wrapup/handle_requested.rs
View File

@@ -1,18 +1,17 @@
use crate::context::AppContext;
use crate::wrapup::{compute, queries::ComputeWrapUpQuery};
use crate::wrapup::{compute, deps::HandleWrapUpRequestedDeps, queries::ComputeWrapUpQuery};
use domain::errors::DomainError;
use domain::events::DomainEvent;
use domain::models::wrapup::{DateRange, WrapUpScope, WrapUpStatus};
use domain::value_objects::WrapUpId;
pub async fn execute(
ctx: &AppContext,
deps: &HandleWrapUpRequestedDeps,
wrapup_id: WrapUpId,
user_id: Option<uuid::Uuid>,
start_date: chrono::NaiveDate,
end_date: chrono::NaiveDate,
) -> Result<(), DomainError> {
if let Ok(Some(rec)) = ctx.repos.wrapup_repo.get_by_id(&wrapup_id).await
if let Ok(Some(rec)) = deps.wrapup_repo.get_by_id(&wrapup_id).await
&& (rec.status == WrapUpStatus::Ready || rec.status == WrapUpStatus::Generating)
{
tracing::debug!(
@@ -23,8 +22,7 @@ pub async fn execute(
return Ok(());
}
ctx.repos
.wrapup_repo
deps.wrapup_repo
.update_status(&wrapup_id, &WrapUpStatus::Generating, None)
.await?;
@@ -37,22 +35,19 @@ pub async fn execute(
date_range: DateRange::new(start_date, end_date)?,
};
match compute::execute(ctx, query).await {
match compute::execute(deps.wrapup_stats.clone(), query).await {
Ok(report) => {
ctx.repos
.wrapup_repo
deps.wrapup_repo
.set_complete(&wrapup_id, &report)
.await?;
ctx.services
.event_publisher
deps.event_publisher
.publish(&DomainEvent::WrapUpCompleted { wrapup_id })
.await?;
Ok(())
}
Err(e) => {
ctx.repos
.wrapup_repo
deps.wrapup_repo
.update_status(&wrapup_id, &WrapUpStatus::Failed, Some(&e.to_string()))
.await?;
Err(e)

11
crates/application/src/wrapup/list_wrapups.rs
View File

@@ -1,21 +1,22 @@
use std::sync::Arc;
use uuid::Uuid;
use domain::errors::DomainError;
use domain::models::wrapup::WrapUpRecord;
use crate::context::AppContext;
use domain::ports::WrapUpRepository;
pub struct ListWrapUpsQuery {
pub user_id: Option<Uuid>,
}
pub async fn execute(
ctx: &AppContext,
wrapup_repo: Arc<dyn WrapUpRepository>,
query: ListWrapUpsQuery,
) -> Result<Vec<WrapUpRecord>, DomainError> {
match query.user_id {
Some(uid) => ctx.repos.wrapup_repo.list_for_user(uid).await,
None => ctx.repos.wrapup_repo.list_global().await,
Some(uid) => wrapup_repo.list_for_user(uid).await,
None => wrapup_repo.list_global().await,
}
}

1
crates/application/src/wrapup/mod.rs
View File

@@ -1,6 +1,7 @@
pub mod commands;
pub mod compute;
pub mod delete;
pub mod deps;
pub mod event_handler;
pub mod generate;
pub mod get_wrapup;

13
crates/application/src/wrapup/tests/compute.rs
View File

@@ -4,7 +4,6 @@ use domain::ports::WrapUpMovieRow;
use domain::testing::InMemoryWrapUpStatsQuery;
use uuid::Uuid;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::queries::ComputeWrapUpQuery;
fn make_row(title: &str, rating: u8, watched_at: &str) -> WrapUpMovieRow {
@@ -42,11 +41,10 @@ fn year_2024_range() -> DateRange {
#[tokio::test]
async fn empty_report() {
let stats = InMemoryWrapUpStatsQuery::new();
let ctx = TestContextBuilder::new().wrapup_stats(stats).build();
let user_id = Uuid::new_v4();
let report = super::execute(
&ctx,
stats,
ComputeWrapUpQuery {
scope: WrapUpScope::User(user_id),
date_range: year_2024_range(),
@@ -74,10 +72,9 @@ async fn basic_stats() {
r2.genres = vec!["Comedy".to_string()];
let stats = InMemoryWrapUpStatsQuery::with_rows(vec![r1, r2]);
let ctx = TestContextBuilder::new().wrapup_stats(stats).build();
let report = super::execute(
&ctx,
stats,
ComputeWrapUpQuery {
scope: WrapUpScope::User(user_id),
date_range: year_2024_range(),
@@ -109,10 +106,9 @@ async fn rewatch_detection() {
r2.movie_id = movie_id;
let stats = InMemoryWrapUpStatsQuery::with_rows(vec![r1, r2]);
let ctx = TestContextBuilder::new().wrapup_stats(stats).build();
let report = super::execute(
&ctx,
stats,
ComputeWrapUpQuery {
scope: WrapUpScope::User(user_id),
date_range: year_2024_range(),
@@ -141,10 +137,9 @@ async fn global_scope() {
r2.user_id = user_b;
let stats = InMemoryWrapUpStatsQuery::with_rows(vec![r1, r2]);
let ctx = TestContextBuilder::new().wrapup_stats(stats).build();
let report = super::execute(
&ctx,
stats,
ComputeWrapUpQuery {
scope: WrapUpScope::Global,
date_range: year_2024_range(),

18
crates/application/src/wrapup/tests/delete.rs
View File

@@ -1,11 +1,8 @@
use std::sync::Arc;
use chrono::NaiveDate;
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
use domain::testing::InMemoryWrapUpRepository;
use domain::value_objects::WrapUpId;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::delete;
#[tokio::test]
@@ -24,22 +21,13 @@ async fn deletes_existing_wrapup() {
completed_at: None,
});
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
..ctx
};
delete::execute(&ctx, id).await.unwrap();
delete::execute(repo.clone(), id).await.unwrap();
assert_eq!(repo.store.lock().unwrap().len(), 0);
}
#[tokio::test]
async fn fails_when_not_found() {
let ctx = TestContextBuilder::new().build();
let result = delete::execute(&ctx, WrapUpId::generate()).await;
let repo = InMemoryWrapUpRepository::new();
let result = delete::execute(repo.clone(), WrapUpId::generate()).await;
assert!(result.is_err());
}

57
crates/application/src/wrapup/tests/generate.rs
View File

@@ -1,5 +1,3 @@
use std::sync::Arc;
use chrono::NaiveDate;
use domain::events::DomainEvent;
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
@@ -7,7 +5,6 @@ use domain::testing::{InMemoryWrapUpRepository, NoopEventPublisher};
use domain::value_objects::WrapUpId;
use uuid::Uuid;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::{commands::RequestWrapUpCommand, generate};
fn past_cmd() -> RequestWrapUpCommand {
@@ -22,22 +19,10 @@ fn past_cmd() -> RequestWrapUpCommand {
async fn creates_pending_record_and_emits_event() {
let repo = InMemoryWrapUpRepository::new();
let events = NoopEventPublisher::new();
let ctx = TestContextBuilder::new()
.wrapup_stats(domain::testing::InMemoryWrapUpStatsQuery::new())
.build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
services: crate::context::Services {
event_publisher: Arc::clone(&events) as _,
..ctx.services
},
config: ctx.config,
};
let id = generate::execute(&ctx, past_cmd()).await.unwrap();
let id = generate::execute(repo.clone(), events.clone(), past_cmd())
.await
.unwrap();
let stored = repo.store.lock().unwrap();
assert_eq!(stored.len(), 1);
@@ -67,17 +52,11 @@ async fn reuses_existing_ready_wrapup() {
created_at: chrono::Utc::now().naive_utc(),
completed_at: None,
});
let events = NoopEventPublisher::new();
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
..ctx
};
let id = generate::execute(&ctx, past_cmd()).await.unwrap();
let id = generate::execute(repo.clone(), events.clone(), past_cmd())
.await
.unwrap();
assert_eq!(id, existing_id);
assert_eq!(repo.store.lock().unwrap().len(), 1);
}
@@ -98,20 +77,10 @@ async fn replaces_failed_wrapup() {
});
let events = NoopEventPublisher::new();
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
services: crate::context::Services {
event_publisher: Arc::clone(&events) as _,
..ctx.services
},
config: ctx.config,
};
let id = generate::execute(&ctx, past_cmd()).await.unwrap();
let id = generate::execute(repo.clone(), events.clone(), past_cmd())
.await
.unwrap();
let stored = repo.store.lock().unwrap();
assert_eq!(stored.len(), 1);
@@ -121,9 +90,11 @@ async fn replaces_failed_wrapup() {
#[tokio::test]
async fn rejects_future_end_date() {
let ctx = TestContextBuilder::new().build();
let repo = InMemoryWrapUpRepository::new();
let events = NoopEventPublisher::new();
let err = generate::execute(
&ctx,
repo.clone(),
events.clone(),
RequestWrapUpCommand {
user_id: None,
start_date: NaiveDate::from_ymd_opt(2030, 1, 1).unwrap(),

18
crates/application/src/wrapup/tests/get_wrapup.rs
View File

@@ -1,11 +1,8 @@
use std::sync::Arc;
use chrono::NaiveDate;
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
use domain::testing::InMemoryWrapUpRepository;
use domain::value_objects::WrapUpId;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::get_wrapup;
#[tokio::test]
@@ -24,24 +21,15 @@ async fn returns_record_when_exists() {
completed_at: None,
});
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
..ctx
};
let result = get_wrapup::execute(&ctx, id).await.unwrap();
let result = get_wrapup::execute(repo.clone(), id).await.unwrap();
assert!(result.is_some());
assert_eq!(result.unwrap().status, WrapUpStatus::Pending);
}
#[tokio::test]
async fn returns_none_when_missing() {
let ctx = TestContextBuilder::new().build();
let result = get_wrapup::execute(&ctx, WrapUpId::generate())
let repo = InMemoryWrapUpRepository::new();
let result = get_wrapup::execute(repo.clone(), WrapUpId::generate())
.await
.unwrap();
assert!(result.is_none());

43
crates/application/src/wrapup/tests/handle_requested.rs
View File

@@ -1,13 +1,10 @@
use std::sync::Arc;
use chrono::{NaiveDate, Utc};
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
use domain::ports::WrapUpRepository;
use domain::testing::InMemoryWrapUpRepository;
use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, NoopEventPublisher};
use domain::value_objects::WrapUpId;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::handle_requested;
use crate::wrapup::{deps::HandleWrapUpRequestedDeps, handle_requested};
#[tokio::test]
async fn skips_if_already_ready() {
@@ -27,12 +24,14 @@ async fn skips_if_already_ready() {
};
repo.create(&record).await.unwrap();
let ctx = TestContextBuilder::new()
.with_wrapup_repo(Arc::clone(&repo) as _)
.build();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: NoopEventPublisher::new(),
wrapup_stats: InMemoryWrapUpStatsQuery::new(),
};
let result = handle_requested::execute(
&ctx,
&deps,
wrapup_id,
None,
NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
@@ -46,8 +45,8 @@ async fn skips_if_already_ready() {
#[tokio::test]
async fn generates_wrapup_and_marks_complete() {
let repo = InMemoryWrapUpRepository::new();
let stats = domain::testing::InMemoryWrapUpStatsQuery::new();
let events = domain::testing::NoopEventPublisher::new();
let stats = InMemoryWrapUpStatsQuery::new();
let events = NoopEventPublisher::new();
let wrapup_id = WrapUpId::generate();
let uid = uuid::Uuid::new_v4();
@@ -64,14 +63,14 @@ async fn generates_wrapup_and_marks_complete() {
};
repo.create(&record).await.unwrap();
let ctx = TestContextBuilder::new()
.with_wrapup_repo(Arc::clone(&repo) as _)
.wrapup_stats(Arc::clone(&stats) as _)
.with_event_publisher(Arc::clone(&events) as _)
.build();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: events.clone(),
wrapup_stats: stats.clone(),
};
let result = handle_requested::execute(
&ctx,
&deps,
wrapup_id.clone(),
Some(uid),
NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
@@ -113,12 +112,14 @@ async fn skips_if_already_generating() {
};
repo.create(&record).await.unwrap();
let ctx = TestContextBuilder::new()
.with_wrapup_repo(Arc::clone(&repo) as _)
.build();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: NoopEventPublisher::new(),
wrapup_stats: InMemoryWrapUpStatsQuery::new(),
};
let result = handle_requested::execute(
&ctx,
&deps,
wrapup_id.clone(),
None,
NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),

25
crates/application/src/wrapup/tests/list_wrapups.rs
View File

@@ -1,12 +1,9 @@
use std::sync::Arc;
use chrono::NaiveDate;
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
use domain::testing::InMemoryWrapUpRepository;
use domain::value_objects::WrapUpId;
use uuid::Uuid;
use crate::test_helpers::TestContextBuilder;
use crate::wrapup::list_wrapups::{self, ListWrapUpsQuery};
fn make_record(user_id: Option<Uuid>) -> WrapUpRecord {
@@ -34,16 +31,7 @@ async fn filters_by_user() {
store.push(make_record(None));
}
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
..ctx
};
let result = list_wrapups::execute(&ctx, ListWrapUpsQuery { user_id: Some(uid) })
let result = list_wrapups::execute(repo.clone(), ListWrapUpsQuery { user_id: Some(uid) })
.await
.unwrap();
assert_eq!(result.len(), 1);
@@ -60,16 +48,7 @@ async fn returns_global_when_no_user() {
store.push(make_record(Some(Uuid::new_v4())));
}
let ctx = TestContextBuilder::new().build();
let ctx = crate::context::AppContext {
repos: crate::context::Repositories {
wrapup_repo: Arc::clone(&repo) as _,
..ctx.repos
},
..ctx
};
let result = list_wrapups::execute(&ctx, ListWrapUpsQuery { user_id: None })
let result = list_wrapups::execute(repo.clone(), ListWrapUpsQuery { user_id: None })
.await
.unwrap();
assert_eq!(result.len(), 2);