refactor: fix HIGH+MEDIUM architectural violations from code review

HIGH: fix watch_medium data-loss bug, standardize error handling on
ApiError, fix dep direction (rss/template-askama no longer dep on
application), extract ImageFetcher port (remove reqwest from app layer),
move event construction from save_review to use case, extract
infra-wiring crate (DbPool/EventBusBackend dedup), deduplicate
presentation helpers (encode_error, export streaming, multipart parsing)

MEDIUM: split LocalApContentQuery god-trait 10→3 methods, dedup movie
resolution orchestration, add RemoteActorDto/PersonDto mappers, move
AppConfig to infra-wiring, fix SocialQueryPort Uuid→UserId, replace
stringly-typed api-types with domain enums, move count_reviews_in_year
to StatsRepository, dedup event publisher cfg blocks, extract
should_enrich, move group_by_month to application, dedup
count_local_posts, add FederationFlags Default, TUI input helper +
ShowError rename + typed auth errors, api-types cleanup
(UserSettingsDto/UserProfileBase/PreviewRowData)

102 files changed, -681 lines net

crates/application/src/diary/get_activity_feed.rs

@@ -6,6 +6,7 @@ use domain::{
         FeedEntry,
         collections::{PageParams, Paginated},
     },
+    value_objects::UserId,
 };
 
 pub async fn execute(
@@ -34,9 +35,10 @@ async fn build_following_filter(
         return None;
     }
     let viewer_id = query.viewer_user_id?;
+    let viewer = UserId::from_uuid(viewer_id);
     let urls = deps
         .social_query
-        .get_accepted_following_urls(viewer_id)
+        .get_accepted_following_urls(&viewer)
         .await
         .unwrap_or_default();
     if urls.is_empty() {

crates/application/src/diary/review_logger.rs

@@ -4,15 +4,15 @@ use async_trait::async_trait;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
-    models::{Movie, Review},
+    models::Review,
     ports::{
         EventPublisher, MetadataClient, MovieRepository, ReviewRepository, WatchlistRepository,
     },
-    value_objects::{Comment, MovieId, Rating, UserId},
+    value_objects::{Comment, Rating, UserId},
 };
 
 use crate::diary::commands::LogReviewCommand;
-use crate::diary::movie_resolver::{MovieResolver, MovieResolverDeps};
+use crate::movies::resolve::resolve_and_persist_movie;
 use crate::ports::ReviewLogger;
 
 pub struct DefaultReviewLogger {
@@ -48,25 +48,18 @@ impl ReviewLogger for DefaultReviewLogger {
         let user_id = UserId::from_uuid(cmd.user_id);
         let comment = cmd.comment.clone().map(Comment::new).transpose()?;
 
-        let (movie, is_new_movie) = if let Some(id) = cmd.input.movie_id {
-            let movie_id = MovieId::from_uuid(id);
-            let movie = self
-                .movie_repo
-                .get_movie_by_id(&movie_id)
-                .await?
-                .ok_or_else(|| DomainError::NotFound(format!("Movie {id}")))?;
-            (movie, false)
-        } else {
-            let deps = MovieResolverDeps {
-                repository: self.movie_repo.as_ref(),
-                metadata_client: self.metadata_client.as_ref(),
-            };
-            MovieResolver::default_pipeline()
-                .resolve(&cmd.input, &deps)
-                .await?
-        };
+        let (movie, is_new_movie) = resolve_and_persist_movie(
+            &cmd.input,
+            self.movie_repo.as_ref(),
+            self.metadata_client.as_ref(),
+            self.event_publisher.as_ref(),
+        )
+        .await?;
 
-        self.movie_repo.upsert_movie(&movie).await?;
+        // Always upsert: even existing movies may have updated metadata
+        if !is_new_movie {
+            self.movie_repo.upsert_movie(&movie).await?;
+        }
 
         let review = Review::new(
             movie.id().clone(),
@@ -76,7 +69,14 @@ impl ReviewLogger for DefaultReviewLogger {
             cmd.watched_at,
             cmd.watch_medium,
         )?;
-        let review_event = self.review_repo.save_review(&review).await?;
+        self.review_repo.save_review(&review).await?;
+        let review_event = DomainEvent::ReviewLogged {
+            review_id: review.id().clone(),
+            movie_id: review.movie_id().clone(),
+            user_id: review.user_id().clone(),
+            rating: review.rating().clone(),
+            watched_at: *review.watched_at(),
+        };
 
         let was_on_watchlist = self
             .watchlist_repo
@@ -92,35 +92,17 @@ impl ReviewLogger for DefaultReviewLogger {
                 .await;
         }
 
-        publish_events(&self.event_publisher, &movie, is_new_movie, review_event).await
-    }
-}
+        if let Some(ext_id) = movie.external_metadata_id() {
+            self.event_publisher
+                .publish(&DomainEvent::MovieEnrichmentRequested {
+                    movie_id: movie.id().clone(),
+                    external_metadata_id: ext_id.clone(),
+                })
+                .await?;
+        }
 
-async fn publish_events(
-    publisher: &Arc<dyn EventPublisher>,
-    movie: &Movie,
-    is_new_movie: bool,
-    review_event: DomainEvent,
-) -> Result<(), DomainError> {
-    if is_new_movie && let Some(ext_id) = movie.external_metadata_id() {
-        publisher
-            .publish(&DomainEvent::MovieDiscovered {
-                movie_id: movie.id().clone(),
-                external_metadata_id: ext_id.clone(),
-            })
-            .await?;
+        self.event_publisher.publish(&review_event).await
     }
-
-    if let Some(ext_id) = movie.external_metadata_id() {
-        publisher
-            .publish(&DomainEvent::MovieEnrichmentRequested {
-                movie_id: movie.id().clone(),
-                external_metadata_id: ext_id.clone(),
-            })
-            .await?;
-    }
-
-    publisher.publish(&review_event).await
 }
 
 #[cfg(test)]

crates/application/src/diary/tests/get_activity_feed.rs

@@ -68,18 +68,27 @@ struct FakeSocialWithFollowing(Vec<String>);
 
 #[async_trait]
 impl domain::ports::SocialQueryPort for FakeSocialWithFollowing {
-    async fn get_accepted_following_urls(&self, _: uuid::Uuid) -> Result<Vec<String>, DomainError> {
+    async fn get_accepted_following_urls(
+        &self,
+        _: &domain::value_objects::UserId,
+    ) -> Result<Vec<String>, DomainError> {
         Ok(self.0.clone())
     }
-    async fn count_following(&self, _: uuid::Uuid) -> Result<usize, DomainError> {
+    async fn count_following(
+        &self,
+        _: &domain::value_objects::UserId,
+    ) -> Result<usize, DomainError> {
         Ok(0)
     }
-    async fn count_accepted_followers(&self, _: uuid::Uuid) -> Result<usize, DomainError> {
+    async fn count_accepted_followers(
+        &self,
+        _: &domain::value_objects::UserId,
+    ) -> Result<usize, DomainError> {
         Ok(0)
     }
     async fn get_pending_followers(
         &self,
-        _: uuid::Uuid,
+        _: &domain::value_objects::UserId,
     ) -> Result<Vec<domain::models::PendingFollowerInfo>, DomainError> {
         Ok(vec![])
     }