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

Refactor application context and repository structure

Browse Source 
- Updated `AppContext` to include separate repositories for movies, reviews, diaries, and stats.
- Modified use cases to utilize the new repository structure, ensuring that the correct repositories are called for their respective operations.
- Introduced `DiaryRepository` and `StatsRepository` traits to encapsulate diary and statistics-related operations.
- Updated all relevant use cases, handlers, and tests to reflect the changes in repository usage.
- Ensured that panic repositories are updated to implement the new traits for testing purposes.
This commit is contained in:
Gabriel Kaszewski
2026-05-09 18:58:29 +02:00
parent 29a5972c01
commit 89e78a0d1f
19 changed files with 260 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
crates/adapters/activitypub/src/event_handler.rs
View File

@@ -2,7 +2,7 @@ use async_trait::async_trait;
use domain::{ use domain::{
errors::DomainError, errors::DomainError,
events::DomainEvent, events::DomainEvent,
ports::MovieRepository, ports::{MovieRepository, ReviewRepository},
value_objects::{ReviewId, UserId}, value_objects::{ReviewId, UserId},
}; };
use domain::ports::EventHandler; use domain::ports::EventHandler;
@@ -15,17 +15,19 @@ use crate::urls::{actor_url, review_url};
pub struct ActivityPubEventHandler { pub struct ActivityPubEventHandler {
ap_service: Arc<ActivityPubService>, ap_service: Arc<ActivityPubService>,
movie_repo: Arc<dyn MovieRepository>, movie_repository: Arc<dyn MovieRepository>,
review_repository: Arc<dyn ReviewRepository>,
base_url: String, base_url: String,
} }
impl ActivityPubEventHandler { impl ActivityPubEventHandler {
pub fn new( pub fn new(
ap_service: Arc<ActivityPubService>, ap_service: Arc<ActivityPubService>,
movie_repo: Arc<dyn MovieRepository>, movie_repository: Arc<dyn MovieRepository>,
review_repository: Arc<dyn ReviewRepository>,
base_url: String, base_url: String,
) -> Self { ) -> Self {
Self { ap_service, movie_repo, base_url } Self { ap_service, movie_repository, review_repository, base_url }
} }
} }
@@ -48,7 +50,7 @@ impl ActivityPubEventHandler {
user_id: &UserId, user_id: &UserId,
review_id: &ReviewId, review_id: &ReviewId,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
let review = match self.movie_repo.get_review_by_id(review_id).await? { let review = match self.review_repository.get_review_by_id(review_id).await? {
Some(r) => r, Some(r) => r,
None => return Ok(()), None => return Ok(()),
}; };
@@ -56,7 +58,7 @@ impl ActivityPubEventHandler {
let ap_id = review_url(&self.base_url, review_id); let ap_id = review_url(&self.base_url, review_id);
let actor = actor_url(&self.base_url, user_id.value()); let actor = actor_url(&self.base_url, user_id.value());
let movie = self.movie_repo.get_movie_by_id(review.movie_id()).await.ok().flatten(); let movie = self.movie_repository.get_movie_by_id(review.movie_id()).await.ok().flatten();
let movie_title = movie.as_ref() let movie_title = movie.as_ref()
.map(|m| m.title().value().to_string()) .map(|m| m.title().value().to_string())
.unwrap_or_else(|| "Unknown".to_string()); .unwrap_or_else(|| "Unknown".to_string());

9
crates/adapters/activitypub/src/review_handler.rs
View File

@@ -4,7 +4,7 @@ use activitypub_base::ApObjectHandler;
use async_trait::async_trait; use async_trait::async_trait;
use domain::{ use domain::{
models::{Review, ReviewSource}, models::{Review, ReviewSource},
ports::MovieRepository, ports::{DiaryRepository, MovieRepository},
value_objects::{Comment, MovieId, Rating, ReviewId, UserId}, value_objects::{Comment, MovieId, Rating, ReviewId, UserId},
}; };
use url::Url; use url::Url;
@@ -14,7 +14,8 @@ use crate::remote_review_repository::RemoteReviewRepository;
use crate::urls::{actor_url, review_url}; use crate::urls::{actor_url, review_url};
pub struct ReviewObjectHandler { pub struct ReviewObjectHandler {
pub movie_repo: Arc<dyn MovieRepository>, pub movie_repository: Arc<dyn MovieRepository>,
pub diary_repository: Arc<dyn DiaryRepository>,
pub review_store: Arc<dyn RemoteReviewRepository>, pub review_store: Arc<dyn RemoteReviewRepository>,
pub base_url: String, pub base_url: String,
} }
@@ -26,7 +27,7 @@ impl ApObjectHandler for ReviewObjectHandler {
user_id: uuid::Uuid, user_id: uuid::Uuid,
) -> anyhow::Result<Vec<(Url, serde_json::Value)>> { ) -> anyhow::Result<Vec<(Url, serde_json::Value)>> {
let domain_user_id = UserId::from_uuid(user_id); let domain_user_id = UserId::from_uuid(user_id);
let history = self.movie_repo.get_user_history(&domain_user_id).await?; let history = self.diary_repository.get_user_history(&domain_user_id).await?;
let mut results = Vec::new(); let mut results = Vec::new();
for entry in history { for entry in history {
@@ -38,7 +39,7 @@ impl ApObjectHandler for ReviewObjectHandler {
let ap_id = review_url(&self.base_url, review.id()); let ap_id = review_url(&self.base_url, review.id());
let actor_url = actor_url(&self.base_url, user_id); let actor_url = actor_url(&self.base_url, user_id);
let movie = self.movie_repo.get_movie_by_id(review.movie_id()).await.ok().flatten(); let movie = self.movie_repository.get_movie_by_id(review.movie_id()).await.ok().flatten();
let movie_title = movie.as_ref() let movie_title = movie.as_ref()
.map(|m| m.title().value().to_string()) .map(|m| m.title().value().to_string())
.unwrap_or_else(|| "Unknown".to_string()); .unwrap_or_else(|| "Unknown".to_string());

157
crates/adapters/sqlite/src/lib.rs
View File

@@ -7,7 +7,7 @@ use domain::{
Review, ReviewHistory, ReviewSource, SortDirection, UserStats, UserTrends, Review, ReviewHistory, ReviewSource, SortDirection, UserStats, UserTrends,
collections::{PageParams, Paginated}, collections::{PageParams, Paginated},
}, },
ports::MovieRepository, ports::{DiaryRepository, MovieRepository, ReviewRepository, StatsRepository},
value_objects::{ExternalMetadataId, MovieId, MovieTitle, ReleaseYear, ReviewId, UserId}, value_objects::{ExternalMetadataId, MovieId, MovieTitle, ReleaseYear, ReviewId, UserId},
}; };
use sqlx::SqlitePool; use sqlx::SqlitePool;
@@ -378,6 +378,18 @@ impl MovieRepository for SqliteMovieRepository {
Ok(()) Ok(())
} }
async fn delete_movie(&self, movie_id: &MovieId) -> Result<(), DomainError> {
let id = movie_id.value().to_string();
sqlx::query!("DELETE FROM movies WHERE id = ?", id)
.execute(&self.pool)
.await
.map_err(Self::map_err)?;
Ok(())
}
}
#[async_trait]
impl ReviewRepository for SqliteMovieRepository {
async fn save_review(&self, review: &Review) -> Result<DomainEvent, DomainError> { async fn save_review(&self, review: &Review) -> Result<DomainEvent, DomainError> {
let id = review.id().value().to_string(); let id = review.id().value().to_string();
let movie_id = review.movie_id().value().to_string(); let movie_id = review.movie_id().value().to_string();
@@ -416,6 +428,33 @@ impl MovieRepository for SqliteMovieRepository {
}) })
} }
async fn get_review_by_id(&self, review_id: &ReviewId) -> Result<Option<Review>, DomainError> {
let id = review_id.value().to_string();
sqlx::query_as!(
ReviewRow,
"SELECT id, movie_id, user_id, rating, comment, watched_at, created_at, remote_actor_url
FROM reviews WHERE id = ?",
id
)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?
.map(ReviewRow::to_domain)
.transpose()
}
async fn delete_review(&self, review_id: &ReviewId) -> Result<(), DomainError> {
let id = review_id.value().to_string();
sqlx::query!("DELETE FROM reviews WHERE id = ?", id)
.execute(&self.pool)
.await
.map_err(Self::map_err)?;
Ok(())
}
}
#[async_trait]
impl DiaryRepository for SqliteMovieRepository {
async fn query_diary(&self, filter: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> { async fn query_diary(&self, filter: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> {
let limit = filter.page.limit as i64; let limit = filter.page.limit as i64;
let offset = filter.page.offset as i64; let offset = filter.page.offset as i64;
@@ -465,37 +504,29 @@ impl MovieRepository for SqliteMovieRepository {
}) })
} }
async fn get_review_by_id(&self, review_id: &ReviewId) -> Result<Option<Review>, DomainError> { async fn query_activity_feed(
let id = review_id.value().to_string(); &self,
sqlx::query_as!( page: &PageParams,
ReviewRow, ) -> Result<Paginated<FeedEntry>, DomainError> {
"SELECT id, movie_id, user_id, rating, comment, watched_at, created_at, remote_actor_url let limit = page.limit as i64;
FROM reviews WHERE id = ?", let offset = page.offset as i64;
id
)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?
.map(ReviewRow::to_domain)
.transpose()
}
async fn delete_review(&self, review_id: &ReviewId) -> Result<(), DomainError> { let (total, rows) = tokio::try_join!(
let id = review_id.value().to_string(); self.count_feed_entries(),
sqlx::query!("DELETE FROM reviews WHERE id = ?", id) self.fetch_feed_rows(limit, offset)
.execute(&self.pool) )?;
.await
.map_err(Self::map_err)?;
Ok(())
}
async fn delete_movie(&self, movie_id: &MovieId) -> Result<(), DomainError> { let items = rows
let id = movie_id.value().to_string(); .into_iter()
sqlx::query!("DELETE FROM movies WHERE id = ?", id) .map(FeedRow::to_domain)
.execute(&self.pool) .collect::<Result<Vec<_>, _>>()?;
.await
.map_err(Self::map_err)?; Ok(Paginated {
Ok(()) items,
total_count: total as u64,
limit: page.limit,
offset: page.offset,
})
} }
async fn get_review_history(&self, movie_id: &MovieId) -> Result<ReviewHistory, DomainError> { async fn get_review_history(&self, movie_id: &MovieId) -> Result<ReviewHistory, DomainError> {
@@ -529,50 +560,6 @@ impl MovieRepository for SqliteMovieRepository {
Ok(ReviewHistory::new(movie, viewings)) Ok(ReviewHistory::new(movie, viewings))
} }
async fn query_activity_feed(
&self,
page: &PageParams,
) -> Result<Paginated<FeedEntry>, DomainError> {
let limit = page.limit as i64;
let offset = page.offset as i64;
let (total, rows) = tokio::try_join!(
self.count_feed_entries(),
self.fetch_feed_rows(limit, offset)
)?;
let items = rows
.into_iter()
.map(FeedRow::to_domain)
.collect::<Result<Vec<_>, _>>()?;
Ok(Paginated {
items,
total_count: total as u64,
limit: page.limit,
offset: page.offset,
})
}
async fn get_user_stats(&self, user_id: &UserId) -> Result<UserStats, DomainError> {
let uid = user_id.value().to_string();
let (totals, fav_director, most_active) = tokio::try_join!(
self.fetch_user_totals(&uid),
self.fetch_user_favorite_director(&uid),
self.fetch_user_most_active_month(&uid)
)?;
let most_active_month = most_active.map(|ym| format_year_month(&ym));
Ok(UserStats {
total_movies: totals.total,
avg_rating: totals.avg_rating,
favorite_director: fav_director,
most_active_month,
})
}
async fn get_user_history(&self, user_id: &UserId) -> Result<Vec<DiaryEntry>, DomainError> { async fn get_user_history(&self, user_id: &UserId) -> Result<Vec<DiaryEntry>, DomainError> {
let uid = user_id.value().to_string(); let uid = user_id.value().to_string();
let rows = sqlx::query_as!( let rows = sqlx::query_as!(
@@ -591,6 +578,28 @@ impl MovieRepository for SqliteMovieRepository {
rows.into_iter().map(DiaryRow::to_domain).collect() rows.into_iter().map(DiaryRow::to_domain).collect()
} }
}
#[async_trait]
impl StatsRepository for SqliteMovieRepository {
async fn get_user_stats(&self, user_id: &UserId) -> Result<UserStats, DomainError> {
let uid = user_id.value().to_string();
let (totals, fav_director, most_active) = tokio::try_join!(
self.fetch_user_totals(&uid),
self.fetch_user_favorite_director(&uid),
self.fetch_user_most_active_month(&uid)
)?;
let most_active_month = most_active.map(|ym| format_year_month(&ym));
Ok(UserStats {
total_movies: totals.total,
avg_rating: totals.avg_rating,
favorite_director: fav_director,
most_active_month,
})
}
async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError> { async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError> {
let uid = user_id.value().to_string(); let uid = user_id.value().to_string();

10
crates/application/src/context.rs
View File

@@ -1,15 +1,19 @@
use std::sync::Arc; use std::sync::Arc;
use domain::ports::{ use domain::ports::{
AuthService, EventPublisher, MetadataClient, MovieRepository, PasswordHasher, AuthService, DiaryRepository, EventPublisher, MetadataClient, MovieRepository,
PosterFetcherClient, PosterStorage, UserRepository, PasswordHasher, PosterFetcherClient, PosterStorage, ReviewRepository, StatsRepository,
UserRepository,
}; };
use crate::config::AppConfig; use crate::config::AppConfig;
#[derive(Clone)] #[derive(Clone)]
pub struct AppContext { pub struct AppContext {
pub repository: Arc<dyn MovieRepository>, pub movie_repository: Arc<dyn MovieRepository>,
pub review_repository: Arc<dyn ReviewRepository>,
pub diary_repository: Arc<dyn DiaryRepository>,
pub stats_repository: Arc<dyn StatsRepository>,
pub metadata_client: Arc<dyn MetadataClient>, pub metadata_client: Arc<dyn MetadataClient>,
pub poster_fetcher: Arc<dyn PosterFetcherClient>, pub poster_fetcher: Arc<dyn PosterFetcherClient>,
pub poster_storage: Arc<dyn PosterStorage>, pub poster_storage: Arc<dyn PosterStorage>,

163
crates/application/src/movie_resolver.rs
View File

@@ -170,12 +170,9 @@ mod tests {
use chrono::NaiveDate; use chrono::NaiveDate;
use domain::{ use domain::{
errors::DomainError, errors::DomainError,
events::DomainEvent, models::Movie,
models::{DiaryEntry, DiaryFilter, Movie, Review, ReviewHistory, collections::Paginated},
ports::{MetadataSearchCriteria, MovieRepository}, ports::{MetadataSearchCriteria, MovieRepository},
value_objects::{ value_objects::{ExternalMetadataId, MovieId, MovieTitle, PosterUrl, ReleaseYear},
ExternalMetadataId, MovieId, MovieTitle, PosterUrl, ReleaseYear, ReviewId,
},
}; };
fn make_cmd(ext_id: Option<&str>, title: Option<&str>, year: Option<u16>) -> LogReviewCommand { fn make_cmd(ext_id: Option<&str>, title: Option<&str>, year: Option<u16>) -> LogReviewCommand {
@@ -210,155 +207,29 @@ mod tests {
#[async_trait] #[async_trait]
impl MovieRepository for RepoWithExternalMovie { impl MovieRepository for RepoWithExternalMovie {
async fn get_movie_by_external_id( async fn get_movie_by_external_id(&self, _: &ExternalMetadataId) -> Result<Option<Movie>, DomainError> { Ok(Some(self.0.clone())) }
&self, async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") }
_: &ExternalMetadataId, async fn get_movies_by_title_and_year(&self, _: &MovieTitle, _: &ReleaseYear) -> Result<Vec<Movie>, DomainError> { panic!("unexpected") }
) -> Result<Option<Movie>, DomainError> { async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> { panic!("unexpected") }
Ok(Some(self.0.clone())) async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> { panic!("unexpected") }
}
async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
panic!("unexpected")
}
async fn get_movies_by_title_and_year(
&self,
_: &MovieTitle,
_: &ReleaseYear,
) -> Result<Vec<Movie>, DomainError> {
panic!("unexpected")
}
async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
panic!("unexpected")
}
async fn query_diary(
&self,
_: &DiaryFilter,
) -> Result<Paginated<DiaryEntry>, DomainError> {
panic!("unexpected")
}
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
panic!("unexpected")
}
async fn get_review_by_id(
&self,
_: &ReviewId,
) -> Result<Option<Review>, DomainError> {
panic!("unexpected")
}
async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, DomainError> { panic!("unexpected") }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, DomainError> { panic!("unexpected") }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, DomainError> { panic!("unexpected") }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, DomainError> { panic!("unexpected") }
} }
#[async_trait] #[async_trait]
impl MovieRepository for RepoEmpty { impl MovieRepository for RepoEmpty {
async fn get_movie_by_external_id( async fn get_movie_by_external_id(&self, _: &ExternalMetadataId) -> Result<Option<Movie>, DomainError> { Ok(None) }
&self, async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") }
_: &ExternalMetadataId, async fn get_movies_by_title_and_year(&self, _: &MovieTitle, _: &ReleaseYear) -> Result<Vec<Movie>, DomainError> { Ok(vec![]) }
) -> Result<Option<Movie>, DomainError> { async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> { panic!("unexpected") }
Ok(None) async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> { panic!("unexpected") }
}
async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
panic!("unexpected")
}
async fn get_movies_by_title_and_year(
&self,
_: &MovieTitle,
_: &ReleaseYear,
) -> Result<Vec<Movie>, DomainError> {
Ok(vec![])
}
async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
panic!("unexpected")
}
async fn query_diary(
&self,
_: &DiaryFilter,
) -> Result<Paginated<DiaryEntry>, DomainError> {
panic!("unexpected")
}
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
panic!("unexpected")
}
async fn get_review_by_id(
&self,
_: &ReviewId,
) -> Result<Option<Review>, DomainError> {
panic!("unexpected")
}
async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, DomainError> { panic!("unexpected") }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, DomainError> { panic!("unexpected") }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, DomainError> { panic!("unexpected") }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, DomainError> { panic!("unexpected") }
} }
#[async_trait] #[async_trait]
impl MovieRepository for RepoWithTitleMatch { impl MovieRepository for RepoWithTitleMatch {
async fn get_movie_by_external_id( async fn get_movie_by_external_id(&self, _: &ExternalMetadataId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") }
&self, async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") }
_: &ExternalMetadataId, async fn get_movies_by_title_and_year(&self, _: &MovieTitle, _: &ReleaseYear) -> Result<Vec<Movie>, DomainError> { Ok(vec![self.0.clone()]) }
) -> Result<Option<Movie>, DomainError> { async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> { panic!("unexpected") }
panic!("unexpected") async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> { panic!("unexpected") }
}
async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
panic!("unexpected")
}
async fn get_movies_by_title_and_year(
&self,
_: &MovieTitle,
_: &ReleaseYear,
) -> Result<Vec<Movie>, DomainError> {
Ok(vec![self.0.clone()])
}
async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> {
panic!("unexpected")
}
async fn query_diary(
&self,
_: &DiaryFilter,
) -> Result<Paginated<DiaryEntry>, DomainError> {
panic!("unexpected")
}
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
panic!("unexpected")
}
async fn get_review_by_id(
&self,
_: &ReviewId,
) -> Result<Option<Review>, DomainError> {
panic!("unexpected")
}
async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
panic!("unexpected")
}
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, DomainError> { panic!("unexpected") }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, DomainError> { panic!("unexpected") }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, DomainError> { panic!("unexpected") }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, DomainError> { panic!("unexpected") }
} }
struct MetaReturnsMovie(Movie); struct MetaReturnsMovie(Movie);

8
crates/application/src/use_cases/delete_review.rs
View File

@@ -6,7 +6,7 @@ pub async fn execute(ctx: &AppContext, cmd: DeleteReviewCommand) -> Result<(), D
let requesting_user_id = UserId::from_uuid(cmd.requesting_user_id); let requesting_user_id = UserId::from_uuid(cmd.requesting_user_id);
let review = ctx let review = ctx
.repository .review_repository
.get_review_by_id(&review_id) .get_review_by_id(&review_id)
.await? .await?
.ok_or_else(|| DomainError::NotFound(format!("review {}", cmd.review_id)))?; .ok_or_else(|| DomainError::NotFound(format!("review {}", cmd.review_id)))?;
@@ -16,11 +16,11 @@ pub async fn execute(ctx: &AppContext, cmd: DeleteReviewCommand) -> Result<(), D
} }
let movie_id = review.movie_id().clone(); let movie_id = review.movie_id().clone();
ctx.repository.delete_review(&review_id).await?; ctx.review_repository.delete_review(&review_id).await?;
let history = ctx.repository.get_review_history(&movie_id).await?; let history = ctx.diary_repository.get_review_history(&movie_id).await?;
if history.viewings().is_empty() { if history.viewings().is_empty() {
ctx.repository.delete_movie(&movie_id).await?; ctx.movie_repository.delete_movie(&movie_id).await?;
} }
Ok(()) Ok(())

4
crates/application/src/use_cases/export_diary.rs
View File

@@ -2,13 +2,13 @@ use std::sync::Arc;
use domain::{ use domain::{
errors::DomainError, errors::DomainError,
ports::{DiaryExporter, MovieRepository}, ports::{DiaryExporter, DiaryRepository},
}; };
use crate::commands::ExportCommand; use crate::commands::ExportCommand;
pub struct ExportDiary { pub struct ExportDiary {
repository: Arc<dyn MovieRepository>, repository: Arc<dyn DiaryRepository>,
exporter: Arc<dyn DiaryExporter>, exporter: Arc<dyn DiaryExporter>,
} }

2
crates/application/src/use_cases/get_activity_feed.rs
View File

@@ -9,5 +9,5 @@ pub async fn execute(
query: GetActivityFeedQuery, query: GetActivityFeedQuery,
) -> Result<Paginated<FeedEntry>, DomainError> { ) -> Result<Paginated<FeedEntry>, DomainError> {
let page = PageParams::new(query.limit, query.offset)?; let page = PageParams::new(query.limit, query.offset)?;
ctx.repository.query_activity_feed(&page).await ctx.diary_repository.query_activity_feed(&page).await
} }

2
crates/application/src/use_cases/get_diary.rs
View File

@@ -24,5 +24,5 @@ pub async fn execute(
user_id, user_id,
}; };
ctx.repository.query_diary(&filter).await ctx.diary_repository.query_diary(&filter).await
} }

2
crates/application/src/use_cases/get_review_history.rs
View File

@@ -13,7 +13,7 @@ pub async fn execute(
) -> Result<(ReviewHistory, Trend), DomainError> { ) -> Result<(ReviewHistory, Trend), DomainError> {
let movie_id = MovieId::from_uuid(query.movie_id); let movie_id = MovieId::from_uuid(query.movie_id);
let mut history = ctx.repository.get_review_history(&movie_id).await?; let mut history = ctx.diary_repository.get_review_history(&movie_id).await?;
let trend = ReviewHistoryAnalyzer::rating_trend(&history)?; let trend = ReviewHistoryAnalyzer::rating_trend(&history)?;

12
crates/application/src/use_cases/get_user_profile.rs
View File

@@ -21,28 +21,26 @@ pub async fn execute(
query: GetUserProfileQuery, query: GetUserProfileQuery,
) -> Result<UserProfileData, DomainError> { ) -> Result<UserProfileData, DomainError> {
let user_id = UserId::from_uuid(query.user_id); let user_id = UserId::from_uuid(query.user_id);
let stats = ctx.repository.get_user_stats(&user_id).await?; let stats = ctx.stats_repository.get_user_stats(&user_id).await?;
match query.view { match query.view {
ProfileView::History => { ProfileView::History => {
// V1: loads all entries into memory. Personal diaries are bounded in size; let all_entries = ctx.diary_repository.get_user_history(&user_id).await?;
// spec calls for showing every movie grouped by month, so full load is intentional.
let all_entries = ctx.repository.get_user_history(&user_id).await?;
let history = group_by_month(all_entries); let history = group_by_month(all_entries);
Ok(UserProfileData { stats, entries: None, history: Some(history), trends: None }) Ok(UserProfileData { stats, entries: None, history: Some(history), trends: None })
} }
ProfileView::Trends => { ProfileView::Trends => {
let trends = ctx.repository.get_user_trends(&user_id).await?; let trends = ctx.stats_repository.get_user_trends(&user_id).await?;
Ok(UserProfileData { stats, entries: None, history: None, trends: Some(trends) }) Ok(UserProfileData { stats, entries: None, history: None, trends: Some(trends) })
} }
ProfileView::Ratings => { ProfileView::Ratings => {
let filter = paged_user_filter(user_id, SortDirection::ByRatingDesc, query.limit, query.offset)?; let filter = paged_user_filter(user_id, SortDirection::ByRatingDesc, query.limit, query.offset)?;
let entries = ctx.repository.query_diary(&filter).await?; let entries = ctx.diary_repository.query_diary(&filter).await?;
Ok(UserProfileData { stats, entries: Some(entries), history: None, trends: None }) Ok(UserProfileData { stats, entries: Some(entries), history: None, trends: None })
} }
ProfileView::Recent => { ProfileView::Recent => {
let filter = paged_user_filter(user_id, SortDirection::Descending, query.limit, query.offset)?; let filter = paged_user_filter(user_id, SortDirection::Descending, query.limit, query.offset)?;
let entries = ctx.repository.query_diary(&filter).await?; let entries = ctx.diary_repository.query_diary(&filter).await?;
Ok(UserProfileData { stats, entries: Some(entries), history: None, trends: None }) Ok(UserProfileData { stats, entries: Some(entries), history: None, trends: None })
} }
} }

6
crates/application/src/use_cases/log_review.rs
View File

@@ -17,15 +17,15 @@ pub async fn execute(ctx: &AppContext, cmd: LogReviewCommand) -> Result<(), Doma
let comment = cmd.comment.clone().map(Comment::new).transpose()?; let comment = cmd.comment.clone().map(Comment::new).transpose()?;
let deps = MovieResolverDeps { let deps = MovieResolverDeps {
repository: ctx.repository.as_ref(), repository: ctx.movie_repository.as_ref(),
metadata_client: ctx.metadata_client.as_ref(), metadata_client: ctx.metadata_client.as_ref(),
}; };
let (movie, is_new_movie) = MovieResolver::default_pipeline().resolve(&cmd, &deps).await?; let (movie, is_new_movie) = MovieResolver::default_pipeline().resolve(&cmd, &deps).await?;
ctx.repository.upsert_movie(&movie).await?; ctx.movie_repository.upsert_movie(&movie).await?;
let review = Review::new(movie.id().clone(), user_id, rating, comment, cmd.watched_at)?; let review = Review::new(movie.id().clone(), user_id, rating, comment, cmd.watched_at)?;
let review_event = ctx.repository.save_review(&review).await?; let review_event = ctx.review_repository.save_review(&review).await?;
publish_events(ctx, &movie, is_new_movie, review_event).await?; publish_events(ctx, &movie, is_new_movie, review_event).await?;

4
crates/application/src/use_cases/sync_poster.rs
View File

@@ -9,7 +9,7 @@ pub async fn execute(ctx: &AppContext, cmd: SyncPosterCommand) -> Result<(), Dom
let movie_id = MovieId::from_uuid(cmd.movie_id); let movie_id = MovieId::from_uuid(cmd.movie_id);
let external_metadata_id = ExternalMetadataId::new(cmd.external_metadata_id)?; let external_metadata_id = ExternalMetadataId::new(cmd.external_metadata_id)?;
let mut movie = match ctx.repository.get_movie_by_id(&movie_id).await? { let mut movie = match ctx.movie_repository.get_movie_by_id(&movie_id).await? {
Some(m) => m, Some(m) => m,
None => { None => {
tracing::warn!( tracing::warn!(
@@ -41,7 +41,7 @@ pub async fn execute(ctx: &AppContext, cmd: SyncPosterCommand) -> Result<(), Dom
.await?; .await?;
movie.update_poster(stored_path); movie.update_poster(stored_path);
ctx.repository.upsert_movie(&movie).await?; ctx.movie_repository.upsert_movie(&movie).await?;
Ok(()) Ok(())
} }

35
crates/domain/src/ports.rs
View File

@@ -27,31 +27,28 @@ pub trait MovieRepository: Send + Sync {
title: &MovieTitle, title: &MovieTitle,
year: &ReleaseYear, year: &ReleaseYear,
) -> Result<Vec<Movie>, DomainError>; ) -> Result<Vec<Movie>, DomainError>;
async fn upsert_movie(&self, movie: &Movie) -> Result<(), DomainError>; async fn upsert_movie(&self, movie: &Movie) -> Result<(), DomainError>;
async fn save_review(&self, review: &Review) -> Result<DomainEvent, DomainError>;
async fn query_diary(&self, filter: &DiaryFilter)
-> Result<Paginated<DiaryEntry>, DomainError>;
async fn get_review_history(&self, movie_id: &MovieId) -> Result<ReviewHistory, DomainError>;
async fn get_review_by_id(&self, review_id: &ReviewId) -> Result<Option<Review>, DomainError>;
async fn delete_review(&self, review_id: &ReviewId) -> Result<(), DomainError>;
async fn delete_movie(&self, movie_id: &MovieId) -> Result<(), DomainError>; async fn delete_movie(&self, movie_id: &MovieId) -> Result<(), DomainError>;
}
async fn query_activity_feed( #[async_trait]
&self, pub trait ReviewRepository: Send + Sync {
page: &PageParams, async fn save_review(&self, review: &Review) -> Result<DomainEvent, DomainError>;
) -> Result<Paginated<FeedEntry>, DomainError>; async fn get_review_by_id(&self, review_id: &ReviewId) -> Result<Option<Review>, DomainError>;
async fn delete_review(&self, review_id: &ReviewId) -> Result<(), DomainError>;
async fn get_user_stats(&self, user_id: &UserId) -> Result<UserStats, DomainError>; }
#[async_trait]
pub trait DiaryRepository: Send + Sync {
async fn query_diary(&self, filter: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError>;
async fn query_activity_feed(&self, page: &PageParams) -> Result<Paginated<FeedEntry>, DomainError>;
async fn get_review_history(&self, movie_id: &MovieId) -> Result<ReviewHistory, DomainError>;
async fn get_user_history(&self, user_id: &UserId) -> Result<Vec<DiaryEntry>, DomainError>; async fn get_user_history(&self, user_id: &UserId) -> Result<Vec<DiaryEntry>, DomainError>;
}
#[async_trait]
pub trait StatsRepository: Send + Sync {
async fn get_user_stats(&self, user_id: &UserId) -> Result<UserStats, DomainError>;
async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError>; async fn get_user_trends(&self, user_id: &UserId) -> Result<UserTrends, DomainError>;
} }

39
crates/presentation/src/event_handlers.rs
View File

@@ -68,10 +68,11 @@ mod tests {
use domain::{ use domain::{
errors::DomainError, errors::DomainError,
events::DomainEvent, events::DomainEvent,
models::{DiaryEntry, DiaryFilter, Movie, Review, ReviewHistory, User, collections::Paginated}, models::{DiaryEntry, DiaryFilter, FeedEntry, Movie, Review, ReviewHistory, User, UserStats, UserTrends, collections::{PageParams, Paginated}},
ports::{ ports::{
AuthService, EventPublisher, GeneratedToken, MetadataClient, MetadataSearchCriteria, AuthService, DiaryRepository, EventPublisher, GeneratedToken, MetadataClient,
MovieRepository, PasswordHasher, PosterFetcherClient, PosterStorage, UserRepository, MetadataSearchCriteria, MovieRepository, PasswordHasher, PosterFetcherClient,
PosterStorage, ReviewRepository, StatsRepository, UserRepository,
}, },
value_objects::{ value_objects::{
Email, ExternalMetadataId, MovieId, MovieTitle, PasswordHash, PosterPath, PosterUrl, Email, ExternalMetadataId, MovieId, MovieTitle, PasswordHash, PosterPath, PosterUrl,
@@ -79,8 +80,6 @@ mod tests {
}, },
}; };
// Panic-stub ports: each method panics so any accidental dispatch into a service
// fails the test loudly rather than silently succeeding.
struct PanicRepo; struct PanicRepo;
struct PanicMetadata; struct PanicMetadata;
struct PanicFetcher; struct PanicFetcher;
@@ -96,16 +95,28 @@ mod tests {
async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") } async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> { panic!("unexpected") }
async fn get_movies_by_title_and_year(&self, _: &MovieTitle, _: &ReleaseYear) -> Result<Vec<Movie>, DomainError> { panic!("unexpected") } async fn get_movies_by_title_and_year(&self, _: &MovieTitle, _: &ReleaseYear) -> Result<Vec<Movie>, DomainError> { panic!("unexpected") }
async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> { panic!("unexpected") } async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> { panic!("unexpected") }
async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> { panic!("unexpected") }
}
#[async_trait]
impl ReviewRepository for PanicRepo {
async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> { panic!("unexpected") } async fn save_review(&self, _: &Review) -> Result<DomainEvent, DomainError> { panic!("unexpected") }
async fn query_diary(&self, _: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> { panic!("unexpected") }
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> { panic!("unexpected") }
async fn get_review_by_id(&self, _: &ReviewId) -> Result<Option<Review>, DomainError> { panic!("unexpected") } async fn get_review_by_id(&self, _: &ReviewId) -> Result<Option<Review>, DomainError> { panic!("unexpected") }
async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> { panic!("unexpected") } async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> { panic!("unexpected") }
async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> { panic!("unexpected") } }
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, DomainError> { panic!("unexpected") }
async fn get_user_stats(&self, _: &UserId) -> Result<domain::models::UserStats, DomainError> { panic!("unexpected") } #[async_trait]
impl DiaryRepository for PanicRepo {
async fn query_diary(&self, _: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> { panic!("unexpected") }
async fn query_activity_feed(&self, _: &PageParams) -> Result<Paginated<FeedEntry>, DomainError> { panic!("unexpected") }
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> { panic!("unexpected") }
async fn get_user_history(&self, _: &UserId) -> Result<Vec<DiaryEntry>, DomainError> { panic!("unexpected") } async fn get_user_history(&self, _: &UserId) -> Result<Vec<DiaryEntry>, DomainError> { panic!("unexpected") }
async fn get_user_trends(&self, _: &UserId) -> Result<domain::models::UserTrends, DomainError> { panic!("unexpected") } }
#[async_trait]
impl StatsRepository for PanicRepo {
async fn get_user_stats(&self, _: &UserId) -> Result<UserStats, DomainError> { panic!("unexpected") }
async fn get_user_trends(&self, _: &UserId) -> Result<UserTrends, DomainError> { panic!("unexpected") }
} }
#[async_trait] #[async_trait]
@@ -152,8 +163,12 @@ mod tests {
} }
fn panic_ctx() -> AppContext { fn panic_ctx() -> AppContext {
let repo = Arc::new(PanicRepo);
AppContext { AppContext {
repository: Arc::new(PanicRepo), movie_repository: Arc::clone(&repo) as _,
review_repository: Arc::clone(&repo) as _,
diary_repository: Arc::clone(&repo) as _,
stats_repository: repo as _,
metadata_client: Arc::new(PanicMetadata), metadata_client: Arc::new(PanicMetadata),
poster_fetcher: Arc::new(PanicFetcher), poster_fetcher: Arc::new(PanicFetcher),
poster_storage: Arc::new(PanicStorage), poster_storage: Arc::new(PanicStorage),

66
crates/presentation/src/extractors.rs
View File

@@ -128,15 +128,24 @@ mod tests {
async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() } async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::ReviewRepository for PanicRepo {
async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() } async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() }
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() } async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() }
async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() } async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() } }
#[async_trait::async_trait]
impl domain::ports::DiaryRepository for PanicRepo {
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() } async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() } async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() } async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::StatsRepository for PanicRepo {
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() } async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() }
} }
@@ -169,7 +178,10 @@ mod tests {
let state = crate::state::AppState { let state = crate::state::AppState {
app_ctx: AppContext { app_ctx: AppContext {
repository: Arc::new(PanicRepo), movie_repository: Arc::new(PanicRepo) as _,
review_repository: Arc::new(PanicRepo) as _,
diary_repository: Arc::new(PanicRepo) as _,
stats_repository: Arc::new(PanicRepo) as _,
metadata_client: Arc::new(PanicMeta), metadata_client: Arc::new(PanicMeta),
poster_fetcher: Arc::new(PanicFetcher), poster_fetcher: Arc::new(PanicFetcher),
poster_storage: Arc::new(PanicStorage), poster_storage: Arc::new(PanicStorage),
@@ -241,15 +253,24 @@ mod tests {
async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() } async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::ReviewRepository for PanicRepo2 {
async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() } async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() }
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() } async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() }
async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() } async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() } }
#[async_trait::async_trait]
impl domain::ports::DiaryRepository for PanicRepo2 {
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() } async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() } async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() } async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::StatsRepository for PanicRepo2 {
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() } async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() }
} }
struct PanicMeta2; struct PanicFetcher2; struct PanicStorage2; struct PanicEvent2; struct PanicHasher2; struct PanicUserRepo2; struct PanicMeta2; struct PanicFetcher2; struct PanicStorage2; struct PanicEvent2; struct PanicHasher2; struct PanicUserRepo2;
@@ -279,7 +300,10 @@ mod tests {
struct PanicAuth2; struct PanicAuth2;
crate::state::AppState { crate::state::AppState {
app_ctx: AppContext { app_ctx: AppContext {
repository: Arc::new(PanicRepo2), movie_repository: Arc::new(PanicRepo2) as _,
review_repository: Arc::new(PanicRepo2) as _,
diary_repository: Arc::new(PanicRepo2) as _,
stats_repository: Arc::new(PanicRepo2) as _,
metadata_client: Arc::new(PanicMeta2), metadata_client: Arc::new(PanicMeta2),
poster_fetcher: Arc::new(PanicFetcher2), poster_fetcher: Arc::new(PanicFetcher2),
poster_storage: Arc::new(PanicStorage2), poster_storage: Arc::new(PanicStorage2),
@@ -305,15 +329,24 @@ mod tests {
async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movie_by_id(&self, _: &domain::value_objects::MovieId) -> Result<Option<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() } async fn get_movies_by_title_and_year(&self, _: &domain::value_objects::MovieTitle, _: &domain::value_objects::ReleaseYear) -> Result<Vec<domain::models::Movie>, domain::errors::DomainError> { panic!() }
async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() } async fn upsert_movie(&self, _: &domain::models::Movie) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::ReviewRepository for PanicRepo3 {
async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() } async fn save_review(&self, _: &domain::models::Review) -> Result<domain::events::DomainEvent, domain::errors::DomainError> { panic!() }
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() } async fn get_review_by_id(&self, _: &domain::value_objects::ReviewId) -> Result<Option<domain::models::Review>, domain::errors::DomainError> { panic!() }
async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() } async fn delete_review(&self, _: &domain::value_objects::ReviewId) -> Result<(), domain::errors::DomainError> { panic!() }
async fn delete_movie(&self, _: &domain::value_objects::MovieId) -> Result<(), domain::errors::DomainError> { panic!() } }
#[async_trait::async_trait]
impl domain::ports::DiaryRepository for PanicRepo3 {
async fn query_diary(&self, _: &domain::models::DiaryFilter) -> Result<domain::models::collections::Paginated<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() } async fn query_activity_feed(&self, _: &domain::models::collections::PageParams) -> Result<domain::models::collections::Paginated<domain::models::FeedEntry>, domain::errors::DomainError> { panic!() }
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() } async fn get_review_history(&self, _: &domain::value_objects::MovieId) -> Result<domain::models::ReviewHistory, domain::errors::DomainError> { panic!() }
async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() } async fn get_user_history(&self, _: &domain::value_objects::UserId) -> Result<Vec<domain::models::DiaryEntry>, domain::errors::DomainError> { panic!() }
}
#[async_trait::async_trait]
impl domain::ports::StatsRepository for PanicRepo3 {
async fn get_user_stats(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserStats, domain::errors::DomainError> { panic!() }
async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() } async fn get_user_trends(&self, _: &domain::value_objects::UserId) -> Result<domain::models::UserTrends, domain::errors::DomainError> { panic!() }
} }
struct PanicMeta3; struct PanicFetcher3; struct PanicStorage3; struct PanicEvent3; struct PanicHasher3; struct PanicUserRepo3; struct PanicMeta3; struct PanicFetcher3; struct PanicStorage3; struct PanicEvent3; struct PanicHasher3; struct PanicUserRepo3;
@@ -341,7 +374,10 @@ mod tests {
} }
crate::state::AppState { crate::state::AppState {
app_ctx: AppContext { app_ctx: AppContext {
repository: Arc::new(PanicRepo3), movie_repository: Arc::new(PanicRepo3) as _,
review_repository: Arc::new(PanicRepo3) as _,
diary_repository: Arc::new(PanicRepo3) as _,
stats_repository: Arc::new(PanicRepo3) as _,
metadata_client: Arc::new(PanicMeta3), metadata_client: Arc::new(PanicMeta3),
poster_fetcher: Arc::new(PanicFetcher3), poster_fetcher: Arc::new(PanicFetcher3),
poster_storage: Arc::new(PanicStorage3), poster_storage: Arc::new(PanicStorage3),

2
crates/presentation/src/handlers.rs
View File

@@ -878,7 +878,7 @@ pub mod api {
) -> Result<impl IntoResponse, ApiError> { ) -> Result<impl IntoResponse, ApiError> {
let movie = state let movie = state
.app_ctx .app_ctx
.repository .movie_repository
.get_movie_by_id(&MovieId::from_uuid(movie_id)) .get_movie_by_id(&MovieId::from_uuid(movie_id))
.await? .await?
.ok_or_else(|| ApiError(DomainError::NotFound(format!("Movie {movie_id}"))))?; .ok_or_else(|| ApiError(DomainError::NotFound(format!("Movie {movie_id}"))))?;

30
crates/presentation/src/main.rs
View File

@@ -60,18 +60,22 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
.await .await
.context("Failed to connect to SQLite database")?; .context("Failed to connect to SQLite database")?;
let movie_repo = SqliteMovieRepository::new(pool.clone()); let sqlite_repo = Arc::new(SqliteMovieRepository::new(pool.clone()));
movie_repo sqlite_repo
.migrate() .migrate()
.await .await
.map_err(|e| anyhow::anyhow!("{}", e)) .map_err(|e| anyhow::anyhow!("{}", e))
.context("Database migration failed")?; .context("Database migration failed")?;
use domain::ports::{ use domain::ports::{
AuthService, MetadataClient, MovieRepository, PasswordHasher, AuthService, DiaryRepository, MetadataClient, MovieRepository, PasswordHasher,
PosterFetcherClient, PosterStorage, UserRepository, PosterFetcherClient, PosterStorage, ReviewRepository, StatsRepository, UserRepository,
}; };
let repository: Arc<dyn MovieRepository> = Arc::new(movie_repo); let movie_repository: Arc<dyn MovieRepository> = Arc::clone(&sqlite_repo) as _;
let review_repository: Arc<dyn ReviewRepository> = Arc::clone(&sqlite_repo) as _;
let diary_repository: Arc<dyn DiaryRepository> = Arc::clone(&sqlite_repo) as _;
let stats_repository: Arc<dyn StatsRepository> = Arc::clone(&sqlite_repo) as _;
let user_repository: Arc<dyn UserRepository> = Arc::new(SqliteUserRepository::new(pool.clone())); let user_repository: Arc<dyn UserRepository> = Arc::new(SqliteUserRepository::new(pool.clone()));
let metadata_client: Arc<dyn MetadataClient> = Arc::new(MetadataClientImpl::new_omdb(omdb_api_key)); let metadata_client: Arc<dyn MetadataClient> = Arc::new(MetadataClientImpl::new_omdb(omdb_api_key));
let poster_fetcher: Arc<dyn PosterFetcherClient> = Arc::new(ReqwestPosterFetcher::new(PosterFetcherConfig::from_env())?); let poster_fetcher: Arc<dyn PosterFetcherClient> = Arc::new(ReqwestPosterFetcher::new(PosterFetcherConfig::from_env())?);
@@ -82,7 +86,10 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
// Build a context for the poster handler. sync_poster doesn't publish events, // Build a context for the poster handler. sync_poster doesn't publish events,
// so a noop publisher here is safe and avoids a circular dependency. // so a noop publisher here is safe and avoids a circular dependency.
let handler_ctx = AppContext { let handler_ctx = AppContext {
repository: Arc::clone(&repository), movie_repository: Arc::clone(&movie_repository),
review_repository: Arc::clone(&review_repository),
diary_repository: Arc::clone(&diary_repository),
stats_repository: Arc::clone(&stats_repository),
metadata_client: Arc::clone(&metadata_client), metadata_client: Arc::clone(&metadata_client),
poster_fetcher: Arc::clone(&poster_fetcher), poster_fetcher: Arc::clone(&poster_fetcher),
poster_storage: Arc::clone(&poster_storage), poster_storage: Arc::clone(&poster_storage),
@@ -97,7 +104,8 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
let federation_repo = Arc::new(SqliteFederationRepository::new(pool)); let federation_repo = Arc::new(SqliteFederationRepository::new(pool));
let user_repo_adapter = Arc::new(DomainUserRepoAdapter(Arc::clone(&user_repository))); let user_repo_adapter = Arc::new(DomainUserRepoAdapter(Arc::clone(&user_repository)));
let review_handler = Arc::new(ReviewObjectHandler { let review_handler = Arc::new(ReviewObjectHandler {
movie_repo: Arc::clone(&repository), movie_repository: Arc::clone(&movie_repository),
diary_repository: Arc::clone(&diary_repository),
review_store: Arc::clone(&federation_repo) as Arc<dyn activitypub::RemoteReviewRepository>, review_store: Arc::clone(&federation_repo) as Arc<dyn activitypub::RemoteReviewRepository>,
base_url: app_config.base_url.clone(), base_url: app_config.base_url.clone(),
}); });
@@ -114,7 +122,8 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
let ap_router = concrete_ap_service.router(); let ap_router = concrete_ap_service.router();
let ap_event_handler = ActivityPubEventHandler::new( let ap_event_handler = ActivityPubEventHandler::new(
Arc::clone(&concrete_ap_service), Arc::clone(&concrete_ap_service),
Arc::clone(&repository), Arc::clone(&movie_repository),
Arc::clone(&review_repository),
app_config.base_url.clone(), app_config.base_url.clone(),
); );
let ap_service: Arc<dyn ActivityPubPort> = concrete_ap_service; let ap_service: Arc<dyn ActivityPubPort> = concrete_ap_service;
@@ -127,7 +136,10 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
tokio::spawn(event_worker.run()); tokio::spawn(event_worker.run());
let app_ctx = AppContext { let app_ctx = AppContext {
repository, movie_repository,
review_repository,
diary_repository,
stats_repository,
metadata_client, metadata_client,
poster_fetcher, poster_fetcher,
poster_storage, poster_storage,

6
crates/presentation/tests/api_test.rs
View File

@@ -96,9 +96,13 @@ async fn test_app() -> Router {
let repo = SqliteMovieRepository::new(pool); let repo = SqliteMovieRepository::new(pool);
repo.migrate().await.expect("migration failed"); repo.migrate().await.expect("migration failed");
let repo = Arc::new(repo);
let state = AppState { let state = AppState {
app_ctx: AppContext { app_ctx: AppContext {
repository: Arc::new(repo), movie_repository: Arc::clone(&repo) as _,
review_repository: Arc::clone(&repo) as _,
diary_repository: Arc::clone(&repo) as _,
stats_repository: Arc::clone(&repo) as _,
metadata_client: Arc::new(PanicMeta), metadata_client: Arc::new(PanicMeta),
poster_fetcher: Arc::new(PanicFetcher), poster_fetcher: Arc::new(PanicFetcher),
poster_storage: Arc::new(PanicStorage), poster_storage: Arc::new(PanicStorage),