refactor: split domain models, move presentation logic out of app layer

Split domain/models/mod.rs (630 lines) into focused files:
movie.rs, review.rs, user.rs, stats.rs, enrichment.rs, feed.rs.

Move URL/date formatting from application use cases to
presentation mappers — use cases now return raw domain data.

Delete watchlist/get_page.rs (was pure presentation logic),
replace with presentation/mappers/watchlist.rs.

Document signature conventions in CONTRIBUTING.md.

crates/application/src/watchlist/get_page.rs

@@ -1,90 +0,0 @@
-use domain::{errors::DomainError, value_objects::UserId};
-
-use crate::{
-    context::AppContext, ports::WatchlistDisplayEntry, watchlist::queries::GetWatchlistQuery,
-};
-
-pub struct WatchlistPageResult {
-    pub display_entries: Vec<WatchlistDisplayEntry>,
-    pub has_more: bool,
-    pub current_offset: u32,
-    pub limit: u32,
-}
-
-pub async fn execute(
-    ctx: &AppContext,
-    query: GetWatchlistQuery,
-    is_owner: bool,
-) -> Result<WatchlistPageResult, DomainError> {
-    let user_id = UserId::from_uuid(query.user_id);
-    let is_local = ctx.repos.user.find_by_id(&user_id).await?.is_some();
-
-    if is_local {
-        let page = crate::watchlist::get::execute(ctx, query).await?;
-        let has_more = page.offset + page.limit < page.total_count as u32;
-        let display_entries = page
-            .items
-            .iter()
-            .map(|w| {
-                let remove_url = if is_owner {
-                    Some(format!("/watchlist/{}/remove", w.movie.id().value()))
-                } else {
-                    None
-                };
-                WatchlistDisplayEntry {
-                    poster_url: w
-                        .movie
-                        .poster_path()
-                        .map(|p| format!("/images/{}", p.value())),
-                    movie_title: w.movie.title().value().to_string(),
-                    release_year: w.movie.release_year().value(),
-                    movie_url: Some(format!("/movies/{}", w.movie.id().value())),
-                    added_at: w.entry.added_at.format("%b %-d, %Y").to_string(),
-                    remove_url,
-                }
-            })
-            .collect();
-        Ok(WatchlistPageResult {
-            display_entries,
-            has_more,
-            current_offset: page.offset,
-            limit: page.limit,
-        })
-    } else {
-        load_remote_watchlist(ctx, query.user_id).await
-    }
-}
-
-async fn load_remote_watchlist(
-    ctx: &AppContext,
-    user_id: uuid::Uuid,
-) -> Result<WatchlistPageResult, DomainError> {
-    let remote_entries = ctx
-        .repos
-        .remote_watchlist
-        .get_by_derived_uuid(user_id)
-        .await
-        .unwrap_or_default();
-    let len = remote_entries.len() as u32;
-    let display_entries = remote_entries
-        .into_iter()
-        .map(|e| WatchlistDisplayEntry {
-            poster_url: e.poster_url,
-            movie_title: e.movie_title,
-            release_year: e.release_year,
-            movie_url: None,
-            added_at: e.added_at.format("%b %-d, %Y").to_string(),
-            remove_url: None,
-        })
-        .collect();
-    Ok(WatchlistPageResult {
-        display_entries,
-        has_more: false,
-        current_offset: 0,
-        limit: len,
-    })
-}
-
-#[cfg(test)]
-#[path = "tests/get_page.rs"]
-mod tests;

crates/application/src/watchlist/mod.rs

@@ -1,7 +1,6 @@
 pub mod add;
 pub mod commands;
 pub mod get;
-pub mod get_page;
 pub mod is_on;
 pub mod queries;
 pub mod remove;

crates/application/src/watchlist/tests/get_page.rs

@@ -1,311 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use domain::errors::DomainError;
-use domain::models::collections::{PageParams, Paginated};
-use domain::models::watchlist::{WatchlistEntry, WatchlistWithMovie};
-use domain::models::{Movie, UserRole};
-use domain::ports::WatchlistRepository;
-use domain::value_objects::{Email, MovieId, MovieTitle, PosterPath, ReleaseYear, UserId};
-
-use crate::auth::commands::RegisterCommand;
-use crate::auth::register;
-use crate::test_helpers::TestContextBuilder;
-use crate::watchlist::get_page;
-use crate::watchlist::queries::GetWatchlistQuery;
-
-struct FakeWatchlistWithItems {
-    user_id: UserId,
-    items: Vec<WatchlistWithMovie>,
-}
-
-#[async_trait]
-impl WatchlistRepository for FakeWatchlistWithItems {
-    async fn add(&self, _entry: &WatchlistEntry) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn remove(&self, _user_id: &UserId, _movie_id: &MovieId) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn remove_if_present(
-        &self,
-        _user_id: &UserId,
-        _movie_id: &MovieId,
-    ) -> Result<bool, DomainError> {
-        Ok(false)
-    }
-    async fn get_for_user(
-        &self,
-        user_id: &UserId,
-        _page: &PageParams,
-    ) -> Result<Paginated<WatchlistWithMovie>, DomainError> {
-        if user_id == &self.user_id {
-            Ok(Paginated {
-                total_count: self.items.len() as u64,
-                limit: 20,
-                offset: 0,
-                items: self.items.clone(),
-            })
-        } else {
-            Ok(Paginated {
-                items: vec![],
-                total_count: 0,
-                limit: 20,
-                offset: 0,
-            })
-        }
-    }
-    async fn contains(&self, _user_id: &UserId, _movie_id: &MovieId) -> Result<bool, DomainError> {
-        Ok(false)
-    }
-}
-
-#[tokio::test]
-async fn returns_empty_for_local_user() {
-    let ctx = TestContextBuilder::new().build();
-
-    register::execute(
-        &ctx,
-        RegisterCommand {
-            email: "wl@test.com".into(),
-            username: "wluser".into(),
-            password: "password123".into(),
-            role: UserRole::Standard,
-        },
-    )
-    .await
-    .unwrap();
-
-    let email = Email::new("wl@test.com".into()).unwrap();
-    let user = ctx.repos.user.find_by_email(&email).await.unwrap().unwrap();
-    let uid = user.id().value();
-
-    let result = get_page::execute(
-        &ctx,
-        GetWatchlistQuery {
-            user_id: uid,
-            limit: None,
-            offset: None,
-        },
-        true,
-    )
-    .await
-    .unwrap();
-
-    assert!(result.display_entries.is_empty());
-}
-
-#[tokio::test]
-async fn returns_display_entries_for_local_user_with_items() {
-    let ctx = TestContextBuilder::new().build();
-
-    register::execute(
-        &ctx,
-        RegisterCommand {
-            email: "wl2@test.com".into(),
-            username: "wluser2".into(),
-            password: "password123".into(),
-            role: UserRole::Standard,
-        },
-    )
-    .await
-    .unwrap();
-
-    let email = Email::new("wl2@test.com".into()).unwrap();
-    let user = ctx.repos.user.find_by_email(&email).await.unwrap().unwrap();
-    let uid = user.id().value();
-
-    let result = get_page::execute(
-        &ctx,
-        GetWatchlistQuery {
-            user_id: uid,
-            limit: Some(20),
-            offset: Some(0),
-        },
-        true,
-    )
-    .await
-    .unwrap();
-
-    // InMemory get_for_user returns empty, but the local-user branch is exercised
-    assert!(!result.has_more);
-    assert_eq!(result.current_offset, 0);
-}
-
-#[tokio::test]
-async fn returns_remote_watchlist_for_unknown_user() {
-    let ctx = TestContextBuilder::new().build();
-
-    let unknown_uid = uuid::Uuid::new_v4();
-
-    let result = get_page::execute(
-        &ctx,
-        GetWatchlistQuery {
-            user_id: unknown_uid,
-            limit: None,
-            offset: None,
-        },
-        false,
-    )
-    .await
-    .unwrap();
-
-    // NoopRemoteWatchlistRepository returns empty
-    assert!(result.display_entries.is_empty());
-    assert!(!result.has_more);
-    assert_eq!(result.current_offset, 0);
-}
-
-#[tokio::test]
-async fn maps_display_entries_for_owner() {
-    let uid = uuid::Uuid::new_v4();
-    let user_id = UserId::from_uuid(uid);
-    let movie_id = MovieId::generate();
-
-    let movie = Movie::from_persistence(
-        movie_id.clone(),
-        None,
-        MovieTitle::new("Blade Runner".into()).unwrap(),
-        ReleaseYear::new(1982).unwrap(),
-        None,
-        Some(PosterPath::new("poster123.jpg".into()).unwrap()),
-    );
-    let entry = WatchlistEntry::new(user_id.clone(), movie_id.clone());
-
-    let fake_wl = Arc::new(FakeWatchlistWithItems {
-        user_id: user_id.clone(),
-        items: vec![WatchlistWithMovie {
-            entry,
-            movie: movie.clone(),
-        }],
-    });
-
-    let ctx = TestContextBuilder::new()
-        .with_watchlist(fake_wl as _)
-        .build();
-
-    // register user so find_by_id returns Some
-    register::execute(
-        &ctx,
-        RegisterCommand {
-            email: "wlmap@test.com".into(),
-            username: "wlmapuser".into(),
-            password: "password123".into(),
-            role: UserRole::Standard,
-        },
-    )
-    .await
-    .unwrap();
-
-    let email = Email::new("wlmap@test.com".into()).unwrap();
-    let user = ctx.repos.user.find_by_email(&email).await.unwrap().unwrap();
-    let real_uid = user.id().value();
-
-    // Rebuild with the real user_id in the fake
-    let movie_id2 = MovieId::generate();
-    let movie2 = Movie::from_persistence(
-        movie_id2.clone(),
-        None,
-        MovieTitle::new("Blade Runner".into()).unwrap(),
-        ReleaseYear::new(1982).unwrap(),
-        None,
-        Some(PosterPath::new("poster123.jpg".into()).unwrap()),
-    );
-    let entry2 = WatchlistEntry::new(UserId::from_uuid(real_uid), movie_id2.clone());
-
-    let fake_wl2 = Arc::new(FakeWatchlistWithItems {
-        user_id: UserId::from_uuid(real_uid),
-        items: vec![WatchlistWithMovie {
-            entry: entry2,
-            movie: movie2.clone(),
-        }],
-    });
-
-    let ctx2 = TestContextBuilder::new()
-        .with_watchlist(fake_wl2 as _)
-        .with_users(ctx.repos.user.clone())
-        .build();
-
-    let result = get_page::execute(
-        &ctx2,
-        GetWatchlistQuery {
-            user_id: real_uid,
-            limit: Some(20),
-            offset: Some(0),
-        },
-        true,
-    )
-    .await
-    .unwrap();
-
-    assert_eq!(result.display_entries.len(), 1);
-    let de = &result.display_entries[0];
-    assert_eq!(de.movie_title, "Blade Runner");
-    assert_eq!(de.release_year, 1982);
-    assert_eq!(de.poster_url.as_deref(), Some("/images/poster123.jpg"));
-    assert!(de.movie_url.is_some());
-    assert!(de.remove_url.is_some()); // owner can remove
-}
-
-#[tokio::test]
-async fn maps_display_entries_for_non_owner() {
-    let ctx = TestContextBuilder::new().build();
-
-    register::execute(
-        &ctx,
-        RegisterCommand {
-            email: "wlno@test.com".into(),
-            username: "wlnoowner".into(),
-            password: "password123".into(),
-            role: UserRole::Standard,
-        },
-    )
-    .await
-    .unwrap();
-
-    let email = Email::new("wlno@test.com".into()).unwrap();
-    let user = ctx.repos.user.find_by_email(&email).await.unwrap().unwrap();
-    let real_uid = user.id().value();
-
-    let movie_id = MovieId::generate();
-    let movie = Movie::from_persistence(
-        movie_id.clone(),
-        None,
-        MovieTitle::new("Alien".into()).unwrap(),
-        ReleaseYear::new(1979).unwrap(),
-        None,
-        None,
-    );
-    let entry = WatchlistEntry::new(UserId::from_uuid(real_uid), movie_id.clone());
-
-    let fake_wl = Arc::new(FakeWatchlistWithItems {
-        user_id: UserId::from_uuid(real_uid),
-        items: vec![WatchlistWithMovie {
-            entry,
-            movie: movie.clone(),
-        }],
-    });
-
-    let ctx2 = TestContextBuilder::new()
-        .with_watchlist(fake_wl as _)
-        .with_users(ctx.repos.user.clone())
-        .build();
-
-    let result = get_page::execute(
-        &ctx2,
-        GetWatchlistQuery {
-            user_id: real_uid,
-            limit: Some(20),
-            offset: Some(0),
-        },
-        false, // not owner
-    )
-    .await
-    .unwrap();
-
-    assert_eq!(result.display_entries.len(), 1);
-    let de = &result.display_entries[0];
-    assert_eq!(de.movie_title, "Alien");
-    assert!(de.poster_url.is_none()); // no poster
-    assert!(de.remove_url.is_none()); // not owner
-}