application layer

Co-authored-by: Copilot <copilot@github.com>

crates/application/Cargo.toml

@@ -4,3 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+domain = { workspace = true }
+uuid = { workspace = true }
+chrono = { workspace = true }
+tracing = { workspace = true }

crates/application/src/commands.rs

@@ -0,0 +1,20 @@
+use chrono::NaiveDateTime;
+use uuid::Uuid;
+
+pub struct LogReviewCommand {
+    pub external_metadata_id: Option<String>,
+
+    pub manual_title: Option<String>,
+    pub manual_release_year: Option<u16>,
+    pub manual_director: Option<String>,
+
+    pub user_id: Uuid,
+    pub rating: u8,
+    pub comment: Option<String>,
+    pub watched_at: NaiveDateTime,
+}
+
+pub struct SyncPosterCommand {
+    pub movie_id: Uuid,
+    pub external_metadata_id: String,
+}

crates/application/src/context.rs

@@ -0,0 +1,17 @@
+use std::sync::Arc;
+
+use domain::ports::{
+    AuthService, EventPublisher, MetadataClient, MovieRepository, PasswordHasher,
+    PosterFetcherClient, PosterStorage,
+};
+
+#[derive(Clone)]
+pub struct AppContext {
+    pub repository: Arc<dyn MovieRepository>,
+    pub metadata_client: Arc<dyn MetadataClient>,
+    pub poster_fetcher: Arc<dyn PosterFetcherClient>,
+    pub poster_storage: Arc<dyn PosterStorage>,
+    pub event_publisher: Arc<dyn EventPublisher>,
+    pub auth_service: Arc<dyn AuthService>,
+    pub password_hasher: Arc<dyn PasswordHasher>,
+}

crates/application/src/lib.rs

@@ -1,14 +1,4 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub mod commands;
+pub mod context;
+pub mod queries;
+pub mod use_cases;

crates/application/src/queries.rs

@@ -0,0 +1,13 @@
+use domain::models::SortDirection;
+use uuid::Uuid;
+
+pub struct GetDiaryQuery {
+    pub limit: Option<u32>,
+    pub offset: Option<u32>,
+    pub sort_by: Option<SortDirection>,
+    pub movie_id: Option<Uuid>,
+}
+
+pub struct GetReviewHistoryQuery {
+    pub movie_id: Uuid,
+}

crates/application/src/use_cases/get_diary.rs

@@ -0,0 +1,29 @@
+use domain::{
+    errors::DomainError,
+    models::{
+        DiaryEntry, DiaryFilter, SortDirection,
+        collections::{PageParams, Paginated},
+    },
+    value_objects::MovieId,
+};
+
+use crate::{context::AppContext, queries::GetDiaryQuery};
+
+pub async fn execute(
+    ctx: &AppContext,
+    query: GetDiaryQuery,
+) -> Result<Paginated<DiaryEntry>, DomainError> {
+    let page = PageParams::new(query.limit, query.offset)?;
+
+    let movie_id = query.movie_id.map(MovieId::from_uuid);
+
+    let filter = DiaryFilter {
+        sort_by: query.sort_by.unwrap_or(SortDirection::Descending),
+        page,
+        movie_id,
+    };
+
+    let paginated_results = ctx.repository.query_diary(&filter).await?;
+
+    Ok(paginated_results)
+}

crates/application/src/use_cases/get_review_history.rs

@@ -0,0 +1,23 @@
+use domain::{
+    errors::DomainError,
+    models::ReviewHistory,
+    services::review_history::{ReviewHistoryAnalyzer, Trend},
+    value_objects::MovieId,
+};
+
+use crate::{context::AppContext, queries::GetReviewHistoryQuery};
+
+pub async fn execute(
+    ctx: &AppContext,
+    query: GetReviewHistoryQuery,
+) -> Result<(ReviewHistory, Trend), DomainError> {
+    let movie_id = MovieId::from_uuid(query.movie_id);
+
+    let mut history = ctx.repository.get_review_history(&movie_id).await?;
+
+    let trend = ReviewHistoryAnalyzer::rating_trend(&history)?;
+
+    ReviewHistoryAnalyzer::sort_chronologically(&mut history);
+
+    Ok((history, trend))
+}

crates/application/src/use_cases/log_review.rs

@@ -0,0 +1,115 @@
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::{Movie, Review},
+    value_objects::{Comment, ExternalMetadataId, MovieTitle, Rating, ReleaseYear, UserId},
+};
+
+use crate::{commands::LogReviewCommand, context::AppContext};
+
+pub async fn execute(ctx: &AppContext, cmd: LogReviewCommand) -> Result<(), DomainError> {
+    let rating = Rating::new(cmd.rating)?;
+    let user_id = UserId::from_uuid(cmd.user_id);
+    let comment = cmd.comment.clone().map(Comment::new).transpose()?;
+
+    let (movie, is_new_movie) = resolve_movie(ctx, &cmd).await?;
+
+    ctx.repository.upsert_movie(&movie).await?;
+
+    let review = Review::new(movie.id().clone(), user_id, rating, comment, cmd.watched_at)?;
+    let review_event = ctx.repository.save_review(&review).await?;
+
+    publish_events(ctx, &movie, is_new_movie, review_event).await?;
+
+    Ok(())
+}
+
+async fn resolve_movie(
+    ctx: &AppContext,
+    cmd: &LogReviewCommand,
+) -> Result<(Movie, bool), DomainError> {
+    if let Some(ext_id_str) = &cmd.external_metadata_id {
+        if let Some(resolved) = resolve_external_movie(ctx, ext_id_str).await? {
+            return Ok(resolved);
+        }
+    }
+
+    resolve_manual_movie(ctx, cmd).await
+}
+
+async fn resolve_external_movie(
+    ctx: &AppContext,
+    ext_id_str: &str,
+) -> Result<Option<(Movie, bool)>, DomainError> {
+    let tmdb_id = ExternalMetadataId::new(ext_id_str.to_string())?;
+
+    if let Some(m) = ctx.repository.get_movie_by_external_id(&tmdb_id).await? {
+        return Ok(Some((m, false)));
+    }
+
+    match ctx.metadata_client.fetch_movie_metadata(&tmdb_id).await {
+        Ok(m) => Ok(Some((m, true))),
+        Err(e) => {
+            tracing::warn!(
+                "Failed to fetch from TMDB, falling back to manual entry: {:?}",
+                e
+            );
+            Ok(None)
+        }
+    }
+}
+
+async fn resolve_manual_movie(
+    ctx: &AppContext,
+    cmd: &LogReviewCommand,
+) -> Result<(Movie, bool), DomainError> {
+    let title_str = cmd.manual_title.as_ref().ok_or_else(|| {
+        DomainError::ValidationError(
+            "Manual title required if TMDB fetch fails or is omitted".into(),
+        )
+    })?;
+    let year_val = cmd.manual_release_year.ok_or_else(|| {
+        DomainError::ValidationError(
+            "Manual release year required if TMDB fetch fails or is omitted".into(),
+        )
+    })?;
+
+    let title = MovieTitle::new(title_str.clone())?;
+    let release_year = ReleaseYear::new(year_val)?;
+
+    let candidates = ctx
+        .repository
+        .get_movies_by_title_and_year(&title, &release_year)
+        .await?;
+
+    let matched_movie = candidates
+        .into_iter()
+        .find(|m| m.is_manual_match(&title, &release_year, cmd.manual_director.as_deref()));
+
+    if let Some(existing_movie) = matched_movie {
+        Ok((existing_movie, false))
+    } else {
+        let new_movie = Movie::new(None, title, release_year, cmd.manual_director.clone(), None);
+        Ok((new_movie, true))
+    }
+}
+
+async fn publish_events(
+    ctx: &AppContext,
+    movie: &Movie,
+    is_new_movie: bool,
+    review_event: DomainEvent,
+) -> Result<(), DomainError> {
+    if is_new_movie {
+        if let Some(ext_id) = movie.external_metadata_id() {
+            let discovery_event = DomainEvent::MovieDiscovered {
+                movie_id: movie.id().clone(),
+                external_metadata_id: ext_id.clone(),
+            };
+            ctx.event_publisher.publish(&discovery_event).await?;
+        }
+    }
+
+    ctx.event_publisher.publish(&review_event).await?;
+    Ok(())
+}

crates/application/src/use_cases/mod.rs

@@ -0,0 +1,4 @@
+pub mod get_diary;
+pub mod get_review_history;
+pub mod log_review;
+pub mod sync_poster;

crates/application/src/use_cases/sync_poster.rs

@@ -0,0 +1,47 @@
+use domain::{
+    errors::DomainError,
+    value_objects::{ExternalMetadataId, MovieId},
+};
+
+use crate::{commands::SyncPosterCommand, context::AppContext};
+
+pub async fn execute(ctx: &AppContext, cmd: SyncPosterCommand) -> Result<(), DomainError> {
+    let movie_id = MovieId::from_uuid(cmd.movie_id);
+    let external_metadata_id = ExternalMetadataId::new(cmd.external_metadata_id)?;
+
+    let mut movie = match ctx.repository.get_movie_by_id(&movie_id).await? {
+        Some(m) => m,
+        None => {
+            tracing::warn!(
+                "Sync cancelled: Movie {} not found in local DB",
+                movie_id.value()
+            );
+            return Err(DomainError::NotFound("Movie not found".into()));
+        }
+    };
+
+    let poster_url = match ctx
+        .metadata_client
+        .get_poster_url(&external_metadata_id)
+        .await
+    {
+        Ok(Some(url)) => url,
+        Ok(None) => return Ok(()),
+        Err(e) => {
+            tracing::warn!("Warning: Failed to find poster URL metadata: {:?}", e);
+            return Err(e);
+        }
+    };
+
+    let image_bytes = ctx.poster_fetcher.fetch_poster_bytes(&poster_url).await?;
+
+    let stored_path = ctx
+        .poster_storage
+        .store_poster(&movie_id, &image_bytes)
+        .await?;
+
+    movie.update_poster(stored_path);
+    ctx.repository.upsert_movie(&movie).await?;
+
+    Ok(())
+}