fmt

crates/adapters/adapter-common/src/lib.rs

@@ -215,9 +215,6 @@ pub fn watchlist_entry_to_domain(
 /// Convert raw watchlist+movie row fields into a [`WatchlistWithMovie`].
 ///
 /// Takes the watchlist entry fields and a pre-converted [`Movie`].
-pub fn watchlist_with_movie_to_domain(
+pub fn watchlist_with_movie_to_domain(entry: WatchlistEntry, movie: Movie) -> WatchlistWithMovie {
-    entry: WatchlistEntry,
-    movie: Movie,
-) -> WatchlistWithMovie {
     WatchlistWithMovie { entry, movie }
 }

crates/adapters/postgres-federation/src/activity.rs

@@ -3,8 +3,8 @@ use async_trait::async_trait;
 use chrono::Utc;
 use k_ap::ActivityRepository;
 
-use adapter_common::datetime_to_str;
 use super::PostgresFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl ActivityRepository for PostgresFederationRepository {

crates/adapters/postgres-federation/src/actor.rs

@@ -4,8 +4,8 @@ use chrono::Utc;
 use k_ap::{ActorRepository, RemoteActor};
 use sqlx::Row;
 
-use adapter_common::datetime_to_str;
 use super::{PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor};
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl ActorRepository for PostgresFederationRepository {

crates/adapters/postgres-federation/src/ap_content.rs

@@ -25,7 +25,7 @@ impl PostgresApContentQuery {
 
 // ── Local row types ──────────────────────────────────────────────────────────
 
-use adapter_common::{parse_uuid, parse_datetime};
+use adapter_common::{parse_datetime, parse_uuid};
 
 #[derive(sqlx::FromRow)]
 struct MovieRow {

crates/adapters/postgres-federation/src/blocklist.rs

@@ -4,8 +4,8 @@ use chrono::Utc;
 use k_ap::{BlockedDomain, BlocklistRepository};
 use sqlx::Row;
 
-use adapter_common::datetime_to_str;
 use super::PostgresFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl BlocklistRepository for PostgresFederationRepository {

crates/adapters/postgres-federation/src/follow.rs

@@ -6,11 +6,10 @@ use k_ap::{
 };
 use sqlx::Row;
 
-use adapter_common::datetime_to_str;
 use super::{
-    PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor, status_to_str,
+    PG_ACTOR_COLS, PostgresFederationRepository, pg_remote_actor, status_to_str, str_to_status,
-    str_to_status,
 };
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl FollowRepository for PostgresFederationRepository {

crates/adapters/postgres-federation/src/remote_goals.rs

@@ -11,7 +11,6 @@ impl PostgresRemoteGoalRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres-federation/src/review.rs

@@ -3,8 +3,8 @@ use anyhow::{Result, anyhow};
 use async_trait::async_trait;
 use domain::models::{Review, ReviewSource};
 
-use adapter_common::datetime_to_str;
 use super::PostgresFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl RemoteReviewRepository for PostgresFederationRepository {

crates/adapters/postgres/src/diary.rs

@@ -22,7 +22,6 @@ impl PostgresDiaryRepository {
         Self { pool }
     }
 
-
     async fn count_diary_entries(&self, movie_id: Option<&str>) -> Result<i64, DomainError> {
         match movie_id {
             None => sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM reviews")
@@ -134,7 +133,9 @@ impl PostgresDiaryRepository {
         if has_search {
             q = q.bind(search.unwrap());
         }
-        q.fetch_one(&self.pool).await.map_err(adapter_common::map_sqlx_error)
+        q.fetch_one(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)
     }
 
     async fn fetch_user_diary_rows(
@@ -371,7 +372,10 @@ impl DiaryQuery for PostgresDiaryRepository {
         }
 
         let count_q = bind_filter_params!(sqlx::query_scalar::<_, i64>(&count_sql));
-        let total = count_q.fetch_one(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let total = count_q
+            .fetch_one(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         let rows_q = bind_filter_params!(sqlx::query_as::<_, FeedRow>(&select_sql));
         let rows = rows_q

crates/adapters/postgres/src/goals.rs

@@ -17,7 +17,6 @@ impl PostgresGoalRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/import_profile.rs

@@ -96,7 +96,6 @@ impl PostgresImportProfileRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/import_session.rs

@@ -202,7 +202,6 @@ impl PostgresImportSessionRepository {
         Self { pool }
     }
 
-
     fn serialize_session(
         s: &ImportSession,
     ) -> Result<(String, Option<String>, Option<String>), DomainError> {

crates/adapters/postgres/src/models.rs

@@ -1,11 +1,11 @@
-use domain::{
-    errors::DomainError,
-    models::{DiaryEntry, FeedEntry, Movie, MovieSummary, Review},
-};
 use adapter_common::{
     movie_row_to_domain, movie_stats_to_domain, movie_summary_to_domain, review_row_to_domain,
     user_summary_to_domain,
 };
+use domain::{
+    errors::DomainError,
+    models::{DiaryEntry, FeedEntry, Movie, MovieSummary, Review},
+};
 
 #[derive(sqlx::FromRow)]
 pub(crate) struct MovieRow {

crates/adapters/postgres/src/movie.rs

@@ -20,7 +20,6 @@ impl PostgresMovieRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/movie_dedup.rs

@@ -12,7 +12,6 @@ impl PostgresMovieDeduplicator {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]
@@ -32,7 +31,11 @@ impl MovieDeduplicator for PostgresMovieDeduplicator {
         let director = canonical.director().map(str::to_string);
         let poster = canonical.poster_path().map(|p| p.value().to_string());
 
-        let mut tx = self.pool.begin().await.map_err(adapter_common::map_sqlx_error)?;
+        let mut tx = self
+            .pool
+            .begin()
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         // 1. Upsert canonical movie record
         sqlx::query(

crates/adapters/postgres/src/persons.rs

@@ -29,7 +29,6 @@ pub fn create_person_adapter(pool: PgPool) -> (Arc<dyn PersonCommand>, Arc<dyn P
     )
 }
 
-
 #[async_trait]
 impl PersonCommand for PostgresPersonAdapter {
     async fn upsert_batch(&self, persons: &[Person]) -> Result<(), DomainError> {

crates/adapters/postgres/src/profile.rs

@@ -16,7 +16,6 @@ impl PostgresMovieProfileRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]
@@ -24,7 +23,11 @@ impl MovieProfileRepository for PostgresMovieProfileRepository {
     async fn upsert(&self, p: &MovieProfile) -> Result<(), DomainError> {
         let movie_id = p.movie_id.value().to_string();
 
-        let mut tx = self.pool.begin().await.map_err(adapter_common::map_sqlx_error)?;
+        let mut tx = self
+            .pool
+            .begin()
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         sqlx::query(
             r#"INSERT INTO movie_profiles

crates/adapters/postgres/src/refresh_sessions.rs

@@ -16,7 +16,6 @@ impl PostgresRefreshSessionAdapter {
     }
 }
 
-
 #[async_trait]
 impl RefreshSessionRepository for PostgresRefreshSessionAdapter {
     async fn create(&self, session: &RefreshSession) -> Result<(), DomainError> {

crates/adapters/postgres/src/review.rs

@@ -7,8 +7,8 @@ use domain::{
 };
 use sqlx::PgPool;
 
-use adapter_common::datetime_to_str;
 use crate::models::ReviewRow;
+use adapter_common::datetime_to_str;
 
 pub struct PostgresReviewRepository {
     pool: PgPool,
@@ -18,7 +18,6 @@ impl PostgresReviewRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/stats.rs

@@ -7,8 +7,8 @@ use domain::{
 };
 use sqlx::PgPool;
 
-use adapter_common::format_year_month;
 use crate::models::{DirectorCountRow, MonthlyRatingRow, UserTotalsRow};
+use adapter_common::format_year_month;
 
 pub struct PostgresStatsRepository {
     pool: PgPool,
@@ -19,7 +19,6 @@ impl PostgresStatsRepository {
         Self { pool }
     }
 
-
     async fn fetch_user_totals(&self, user_id: &str) -> Result<UserTotalsRow, DomainError> {
         sqlx::query_as::<_, UserTotalsRow>(
             r#"SELECT COUNT(DISTINCT movie_id) AS total,

crates/adapters/postgres/src/user_settings.rs

@@ -15,7 +15,6 @@ impl PostgresUserSettingsRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/users.rs

@@ -20,7 +20,6 @@ impl PostgresUserRepository {
         Self { pool }
     }
 
-
     fn parse_role(s: &str) -> UserRole {
         match s {
             "admin" => UserRole::Admin,

crates/adapters/postgres/src/watch_event.rs

@@ -9,7 +9,6 @@ use sqlx::{PgPool, Row};
 
 use adapter_common::{parse_datetime, parse_uuid};
 
-
 // ── WatchEventRepository ──────────────────────────────────────────────────────
 
 pub struct PostgresWatchEventRepository {
@@ -191,15 +190,33 @@ impl WatchEventQuery for PostgresWatchEventRepository {
 
 fn row_to_watch_event(row: &sqlx::postgres::PgRow) -> Result<WatchEvent, DomainError> {
     let id_str: String = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: String = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: String = row
-    let movie_id_str: Option<String> = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let title: String = row.try_get("title").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let year: Option<i32> = row.try_get("year").map_err(adapter_common::map_sqlx_error)?;
+    let movie_id_str: Option<String> = row
-    let ext_id: Option<String> = row.try_get("external_metadata_id").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("movie_id")
-    let source_str: String = row.try_get("source").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let watched_at_str: String = row.try_get("watched_at").map_err(adapter_common::map_sqlx_error)?;
+    let title: String = row
-    let status_str: String = row.try_get("status").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("title")
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
+    let year: Option<i32> = row
+        .try_get("year")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let ext_id: Option<String> = row
+        .try_get("external_metadata_id")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let source_str: String = row
+        .try_get("source")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let watched_at_str: String = row
+        .try_get("watched_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let status_str: String = row
+        .try_get("status")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let source: WatchEventSource = source_str
         .parse()
@@ -330,12 +347,24 @@ impl WebhookTokenRepository for PostgresWebhookTokenRepository {
 
 fn row_to_webhook_token(row: &sqlx::postgres::PgRow) -> Result<WebhookToken, DomainError> {
     let id_str: String = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: String = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: String = row
-    let token_hash: String = row.try_get("token_hash").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let provider_str: String = row.try_get("provider").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let label: Option<String> = row.try_get("label").map_err(adapter_common::map_sqlx_error)?;
+    let token_hash: String = row
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("token_hash")
-    let last_used_str: Option<String> = row.try_get("last_used_at").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
+    let provider_str: String = row
+        .try_get("provider")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let label: Option<String> = row
+        .try_get("label")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let last_used_str: Option<String> = row
+        .try_get("last_used_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let provider: WatchEventSource = provider_str
         .parse()

crates/adapters/postgres/src/watchlist.rs

@@ -10,8 +10,8 @@ use domain::{
 };
 use sqlx::{PgPool, Row};
 
-use adapter_common::{parse_datetime, parse_uuid};
 use crate::models::MovieRow;
+use adapter_common::{parse_datetime, parse_uuid};
 
 pub struct PostgresWatchlistRepository {
     pool: PgPool,
@@ -21,7 +21,6 @@ impl PostgresWatchlistRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/postgres/src/wrapup.rs

@@ -15,7 +15,6 @@ use uuid::Uuid;
 
 use adapter_common::{parse_datetime, parse_uuid};
 
-
 fn status_to_str(s: &WrapUpStatus) -> &'static str {
     match s {
         WrapUpStatus::Pending => "pending",
@@ -216,14 +215,30 @@ impl WrapUpRepository for PostgresWrapUpRepository {
 
 fn row_to_record(row: &sqlx::postgres::PgRow) -> Result<WrapUpRecord, DomainError> {
     let id_str: String = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: Option<String> = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: Option<String> = row
-    let start_date: NaiveDate = row.try_get("start_date").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let end_date: NaiveDate = row.try_get("end_date").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let status_str: String = row.try_get("status").map_err(adapter_common::map_sqlx_error)?;
+    let start_date: NaiveDate = row
-    let report_json: Option<String> = row.try_get("report_json").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("start_date")
-    let error_message: Option<String> = row.try_get("error_message").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+    let end_date: NaiveDate = row
-    let completed_at_str: Option<String> = row.try_get("completed_at").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("end_date")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let status_str: String = row
+        .try_get("status")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let report_json: Option<String> = row
+        .try_get("report_json")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let error_message: Option<String> = row
+        .try_get("error_message")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let completed_at_str: Option<String> = row
+        .try_get("completed_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let user_id = user_id_str.as_deref().map(parse_uuid).transpose()?;
 
@@ -288,7 +303,10 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
             q = q.bind(uid);
         }
 
-        let rows = q.fetch_all(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let rows = q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         if rows.is_empty() {
             return Ok(vec![]);
@@ -298,7 +316,9 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
         let mut movie_ids: Vec<String> = Vec::new();
         let mut seen = std::collections::HashSet::new();
         for row in &rows {
-            let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+            let mid: String = row
+                .try_get("movie_id")
+                .map_err(adapter_common::map_sqlx_error)?;
             if seen.insert(mid.clone()) {
                 movie_ids.push(mid);
             }
@@ -314,18 +334,39 @@ impl WrapUpStatsQuery for PostgresWrapUpStatsQuery {
         // 3) Build result
         let mut result = Vec::with_capacity(rows.len());
         for row in &rows {
-            let movie_id_str: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+            let movie_id_str: String = row
-            let title: String = row.try_get("title").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("movie_id")
-            let release_year: i64 = row.try_get("release_year").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let director: Option<String> = row.try_get("director").map_err(adapter_common::map_sqlx_error)?;
+            let title: String = row
-            let poster_path: Option<String> = row.try_get("poster_path").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("title")
-            let rating: i64 = row.try_get("rating").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let watched_at_str: String = row.try_get("watched_at").map_err(adapter_common::map_sqlx_error)?;
+            let release_year: i64 = row
-            let user_id_str: String = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("release_year")
-            let runtime_minutes: Option<i32> = row.try_get("runtime_minutes").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let budget_usd: Option<i64> = row.try_get("budget_usd").map_err(adapter_common::map_sqlx_error)?;
+            let director: Option<String> = row
-            let original_language: Option<String> =
+                .try_get("director")
-                row.try_get("original_language").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
+            let poster_path: Option<String> = row
+                .try_get("poster_path")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let rating: i64 = row
+                .try_get("rating")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let watched_at_str: String = row
+                .try_get("watched_at")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let user_id_str: String = row
+                .try_get("user_id")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let runtime_minutes: Option<i32> = row
+                .try_get("runtime_minutes")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let budget_usd: Option<i64> = row
+                .try_get("budget_usd")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let original_language: Option<String> = row
+                .try_get("original_language")
+                .map_err(adapter_common::map_sqlx_error)?;
 
             let genres = genres_map.get(&movie_id_str).cloned().unwrap_or_default();
             let keywords = keywords_map.get(&movie_id_str).cloned().unwrap_or_default();
@@ -383,8 +424,12 @@ async fn fetch_genres_pg(
 
     let mut map: HashMap<String, Vec<String>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(name);
     }
     Ok(map)
@@ -404,8 +449,12 @@ async fn fetch_keywords_pg(
 
     let mut map: HashMap<String, Vec<String>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(name);
     }
     Ok(map)
@@ -428,11 +477,21 @@ async fn fetch_cast_pg(
 
     let mut map: HashMap<String, Vec<CastEntry>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
-        let billing_order: i32 = row.try_get("billing_order").map_err(adapter_common::map_sqlx_error)?;
+            .map_err(adapter_common::map_sqlx_error)?;
-        let tmdb_person_id: i64 = row.try_get("tmdb_person_id").map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
-        let profile_path: Option<String> = row.try_get("profile_path").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let billing_order: i32 = row
+            .try_get("billing_order")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let tmdb_person_id: i64 = row
+            .try_get("tmdb_person_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let profile_path: Option<String> = row
+            .try_get("profile_path")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(CastEntry {
             name,
             billing_order: billing_order as u32,

crates/adapters/sqlite-federation/src/activity.rs

@@ -3,8 +3,8 @@ use async_trait::async_trait;
 use chrono::Utc;
 use k_ap::ActivityRepository;
 
-use adapter_common::datetime_to_str;
 use super::SqliteFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl ActivityRepository for SqliteFederationRepository {

crates/adapters/sqlite-federation/src/actor.rs

@@ -4,8 +4,8 @@ use chrono::Utc;
 use k_ap::{ActorRepository, RemoteActor};
 use sqlx::Row;
 
-use adapter_common::datetime_to_str;
 use super::{SqliteFederationRepository, remote_actor_from_row};
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl ActorRepository for SqliteFederationRepository {

crates/adapters/sqlite-federation/src/ap_content.rs

@@ -21,12 +21,11 @@ impl SqliteApContentQuery {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 // ── Local row types ──────────────────────────────────────────────────────────
 
-use adapter_common::{parse_uuid, parse_datetime};
+use adapter_common::{parse_datetime, parse_uuid};
 
 #[derive(sqlx::FromRow)]
 struct MovieRow {

crates/adapters/sqlite-federation/src/blocklist.rs

@@ -4,8 +4,8 @@ use chrono::Utc;
 use k_ap::{BlockedDomain, BlocklistRepository};
 use sqlx::Row;
 
-use adapter_common::datetime_to_str;
 use super::SqliteFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl BlocklistRepository for SqliteFederationRepository {

crates/adapters/sqlite-federation/src/follow.rs

@@ -6,11 +6,8 @@ use k_ap::{
 };
 use sqlx::Row;
 
+use super::{SqliteFederationRepository, remote_actor_from_row, status_to_str, str_to_status};
 use adapter_common::datetime_to_str;
-use super::{
-    SqliteFederationRepository, remote_actor_from_row, status_to_str,
-    str_to_status,
-};
 
 #[async_trait]
 impl FollowRepository for SqliteFederationRepository {

crates/adapters/sqlite-federation/src/remote_goals.rs

@@ -11,7 +11,6 @@ impl SqliteRemoteGoalRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite-federation/src/review.rs

@@ -3,8 +3,8 @@ use anyhow::{Result, anyhow};
 use async_trait::async_trait;
 use domain::models::{Review, ReviewSource};
 
-use adapter_common::datetime_to_str;
 use super::SqliteFederationRepository;
+use adapter_common::datetime_to_str;
 
 #[async_trait]
 impl RemoteReviewRepository for SqliteFederationRepository {

crates/adapters/sqlite/src/diary.rs

@@ -125,7 +125,9 @@ impl SqliteDiaryRepository {
         if has_search {
             q = q.bind(search.unwrap());
         }
-        q.fetch_one(&self.pool).await.map_err(adapter_common::map_sqlx_error)
+        q.fetch_one(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)
     }
 
     async fn fetch_user_diary_rows(
@@ -335,7 +337,10 @@ impl DiaryQuery for SqliteDiaryRepository {
         }
 
         let count_q = bind_filter_params!(sqlx::query_scalar::<_, i64>(&count_sql));
-        let total = count_q.fetch_one(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let total = count_q
+            .fetch_one(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         let rows_q = bind_filter_params!(sqlx::query_as::<_, FeedRow>(&select_sql));
         let rows = rows_q

crates/adapters/sqlite/src/goals.rs

@@ -15,7 +15,6 @@ impl SqliteGoalRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite/src/models.rs

@@ -1,11 +1,11 @@
-use domain::{
-    errors::DomainError,
-    models::{DiaryEntry, FeedEntry, Movie, MovieSummary, Review, WatchlistWithMovie},
-};
 use adapter_common::{
     movie_row_to_domain, movie_stats_to_domain, movie_summary_to_domain, review_row_to_domain,
     user_summary_to_domain, watchlist_entry_to_domain, watchlist_with_movie_to_domain,
 };
+use domain::{
+    errors::DomainError,
+    models::{DiaryEntry, FeedEntry, Movie, MovieSummary, Review, WatchlistWithMovie},
+};
 
 #[derive(sqlx::FromRow)]
 pub(crate) struct MovieRow {
@@ -280,12 +280,7 @@ pub(crate) struct WatchlistRow {
 
 impl WatchlistRow {
     pub fn into_domain(self) -> Result<WatchlistWithMovie, DomainError> {
-        let entry = watchlist_entry_to_domain(
+        let entry = watchlist_entry_to_domain(self.id, self.user_id, self.movie_id, self.added_at)?;
-            self.id,
-            self.user_id,
-            self.movie_id,
-            self.added_at,
-        )?;
         let movie = movie_row_to_domain(
             self.m_id,
             self.external_metadata_id,

crates/adapters/sqlite/src/movie.rs

@@ -20,7 +20,6 @@ impl SqliteMovieRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]
@@ -137,7 +136,10 @@ impl MovieQuery for SqliteMovieRepository {
         for id in ids {
             q = q.bind(id.value().to_string());
         }
-        let rows = q.fetch_all(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let rows = q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
         Ok(rows.into_iter().collect())
     }
 
@@ -161,7 +163,10 @@ impl MovieQuery for SqliteMovieRepository {
         for (t, y) in pairs {
             q = q.bind(t.value().to_string()).bind(y.value() as i64);
         }
-        let rows = q.fetch_all(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let rows = q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
         Ok(rows
             .into_iter()
             .map(|r| {

crates/adapters/sqlite/src/movie_dedup.rs

@@ -12,7 +12,6 @@ impl SqliteMovieDeduplicator {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]
@@ -32,7 +31,11 @@ impl MovieDeduplicator for SqliteMovieDeduplicator {
         let director = canonical.director().map(str::to_string);
         let poster = canonical.poster_path().map(|p| p.value().to_string());
 
-        let mut tx = self.pool.begin().await.map_err(adapter_common::map_sqlx_error)?;
+        let mut tx = self
+            .pool
+            .begin()
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         // 1. Upsert canonical movie record
         sqlx::query(

crates/adapters/sqlite/src/profile.rs

@@ -16,7 +16,6 @@ impl SqliteMovieProfileRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]
@@ -25,7 +24,11 @@ impl MovieProfileRepository for SqliteMovieProfileRepository {
         let movie_id = p.movie_id.value().to_string();
         let enriched_at = p.enriched_at.to_rfc3339();
 
-        let mut tx = self.pool.begin().await.map_err(adapter_common::map_sqlx_error)?;
+        let mut tx = self
+            .pool
+            .begin()
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         sqlx::query(
             r#"INSERT INTO movie_profiles

crates/adapters/sqlite/src/profile_fields.rs

@@ -14,7 +14,6 @@ impl SqliteProfileFieldsRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite/src/review.rs

@@ -7,8 +7,8 @@ use domain::{
 };
 use sqlx::SqlitePool;
 
-use adapter_common::datetime_to_str;
 use crate::models::ReviewRow;
+use adapter_common::datetime_to_str;
 
 pub struct SqliteReviewRepository {
     pool: SqlitePool,
@@ -18,7 +18,6 @@ impl SqliteReviewRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite/src/user_settings.rs

@@ -15,7 +15,6 @@ impl SqliteUserSettingsRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite/src/watch_event.rs

@@ -100,7 +100,10 @@ impl WatchEventCommand for SqliteWatchEventRepository {
         for id in ids {
             q = q.bind(id.value().to_string());
         }
-        let result = q.execute(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let result = q
+            .execute(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
         Ok(result.rows_affected())
     }
 
@@ -170,7 +173,10 @@ impl WatchEventQuery for SqliteWatchEventRepository {
         for id in ids {
             q = q.bind(id.value().to_string());
         }
-        let rows = q.fetch_all(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let rows = q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
         rows.iter().map(row_to_watch_event).collect()
     }
 
@@ -202,15 +208,33 @@ impl WatchEventQuery for SqliteWatchEventRepository {
 
 fn row_to_watch_event(row: &sqlx::sqlite::SqliteRow) -> Result<WatchEvent, DomainError> {
     let id_str: &str = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: &str = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: &str = row
-    let movie_id_str: Option<&str> = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let title: String = row.try_get("title").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let year: Option<i64> = row.try_get("year").map_err(adapter_common::map_sqlx_error)?;
+    let movie_id_str: Option<&str> = row
-    let ext_id: Option<String> = row.try_get("external_metadata_id").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("movie_id")
-    let source_str: String = row.try_get("source").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let watched_at_str: String = row.try_get("watched_at").map_err(adapter_common::map_sqlx_error)?;
+    let title: String = row
-    let status_str: String = row.try_get("status").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("title")
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
+    let year: Option<i64> = row
+        .try_get("year")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let ext_id: Option<String> = row
+        .try_get("external_metadata_id")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let source_str: String = row
+        .try_get("source")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let watched_at_str: String = row
+        .try_get("watched_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let status_str: String = row
+        .try_get("status")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let source: WatchEventSource = source_str
         .parse()
@@ -340,12 +364,24 @@ impl WebhookTokenRepository for SqliteWebhookTokenRepository {
 
 fn row_to_webhook_token(row: &sqlx::sqlite::SqliteRow) -> Result<WebhookToken, DomainError> {
     let id_str: &str = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: &str = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: &str = row
-    let token_hash: String = row.try_get("token_hash").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let provider_str: String = row.try_get("provider").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let label: Option<String> = row.try_get("label").map_err(adapter_common::map_sqlx_error)?;
+    let token_hash: String = row
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("token_hash")
-    let last_used_str: Option<String> = row.try_get("last_used_at").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
+    let provider_str: String = row
+        .try_get("provider")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let label: Option<String> = row
+        .try_get("label")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let last_used_str: Option<String> = row
+        .try_get("last_used_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let provider: WatchEventSource = provider_str
         .parse()

crates/adapters/sqlite/src/watchlist.rs

@@ -10,8 +10,8 @@ use domain::{
 };
 use sqlx::{Row, SqlitePool};
 
-use adapter_common::datetime_to_str;
 use crate::models::WatchlistRow;
+use adapter_common::datetime_to_str;
 
 pub struct SqliteWatchlistRepository {
     pool: SqlitePool,
@@ -21,7 +21,6 @@ impl SqliteWatchlistRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
 }
 
 #[async_trait]

crates/adapters/sqlite/src/wrapup.rs

@@ -226,14 +226,30 @@ impl WrapUpRepository for SqliteWrapUpRepository {
 
 fn row_to_record(row: &sqlx::sqlite::SqliteRow) -> Result<WrapUpRecord, DomainError> {
     let id_str: String = row.try_get("id").map_err(adapter_common::map_sqlx_error)?;
-    let user_id_str: Option<String> = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+    let user_id_str: Option<String> = row
-    let start_date_str: String = row.try_get("start_date").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("user_id")
-    let end_date_str: String = row.try_get("end_date").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let status_str: String = row.try_get("status").map_err(adapter_common::map_sqlx_error)?;
+    let start_date_str: String = row
-    let report_json: Option<String> = row.try_get("report_json").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("start_date")
-    let error_message: Option<String> = row.try_get("error_message").map_err(adapter_common::map_sqlx_error)?;
+        .map_err(adapter_common::map_sqlx_error)?;
-    let created_at_str: String = row.try_get("created_at").map_err(adapter_common::map_sqlx_error)?;
+    let end_date_str: String = row
-    let completed_at_str: Option<String> = row.try_get("completed_at").map_err(adapter_common::map_sqlx_error)?;
+        .try_get("end_date")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let status_str: String = row
+        .try_get("status")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let report_json: Option<String> = row
+        .try_get("report_json")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let error_message: Option<String> = row
+        .try_get("error_message")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let created_at_str: String = row
+        .try_get("created_at")
+        .map_err(adapter_common::map_sqlx_error)?;
+    let completed_at_str: Option<String> = row
+        .try_get("completed_at")
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let user_id = user_id_str.as_deref().map(parse_uuid).transpose()?;
 
@@ -299,7 +315,10 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
             q = q.bind(uid);
         }
 
-        let rows = q.fetch_all(&self.pool).await.map_err(adapter_common::map_sqlx_error)?;
+        let rows = q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(adapter_common::map_sqlx_error)?;
 
         if rows.is_empty() {
             return Ok(vec![]);
@@ -309,7 +328,9 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
         let mut movie_ids: Vec<String> = Vec::new();
         let mut seen = std::collections::HashSet::new();
         for row in &rows {
-            let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+            let mid: String = row
+                .try_get("movie_id")
+                .map_err(adapter_common::map_sqlx_error)?;
             if seen.insert(mid.clone()) {
                 movie_ids.push(mid);
             }
@@ -325,18 +346,39 @@ impl WrapUpStatsQuery for SqliteWrapUpStatsQuery {
         // 3) Build result
         let mut result = Vec::with_capacity(rows.len());
         for row in &rows {
-            let movie_id_str: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+            let movie_id_str: String = row
-            let title: String = row.try_get("title").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("movie_id")
-            let release_year: i64 = row.try_get("release_year").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let director: Option<String> = row.try_get("director").map_err(adapter_common::map_sqlx_error)?;
+            let title: String = row
-            let poster_path: Option<String> = row.try_get("poster_path").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("title")
-            let rating: i64 = row.try_get("rating").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let watched_at_str: String = row.try_get("watched_at").map_err(adapter_common::map_sqlx_error)?;
+            let release_year: i64 = row
-            let user_id_str: String = row.try_get("user_id").map_err(adapter_common::map_sqlx_error)?;
+                .try_get("release_year")
-            let runtime_minutes: Option<i32> = row.try_get("runtime_minutes").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
-            let budget_usd: Option<i64> = row.try_get("budget_usd").map_err(adapter_common::map_sqlx_error)?;
+            let director: Option<String> = row
-            let original_language: Option<String> =
+                .try_get("director")
-                row.try_get("original_language").map_err(adapter_common::map_sqlx_error)?;
+                .map_err(adapter_common::map_sqlx_error)?;
+            let poster_path: Option<String> = row
+                .try_get("poster_path")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let rating: i64 = row
+                .try_get("rating")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let watched_at_str: String = row
+                .try_get("watched_at")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let user_id_str: String = row
+                .try_get("user_id")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let runtime_minutes: Option<i32> = row
+                .try_get("runtime_minutes")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let budget_usd: Option<i64> = row
+                .try_get("budget_usd")
+                .map_err(adapter_common::map_sqlx_error)?;
+            let original_language: Option<String> = row
+                .try_get("original_language")
+                .map_err(adapter_common::map_sqlx_error)?;
 
             let genres = genres_map.get(&movie_id_str).cloned().unwrap_or_default();
             let keywords = keywords_map.get(&movie_id_str).cloned().unwrap_or_default();
@@ -406,12 +448,19 @@ async fn fetch_genres_sqlite(
     for id in movie_ids {
         q = q.bind(id);
     }
-    let rows = q.fetch_all(pool).await.map_err(adapter_common::map_sqlx_error)?;
+    let rows = q
+        .fetch_all(pool)
+        .await
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let mut map: HashMap<String, Vec<String>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(name);
     }
     Ok(map)
@@ -432,12 +481,19 @@ async fn fetch_keywords_sqlite(
     for id in movie_ids {
         q = q.bind(id);
     }
-    let rows = q.fetch_all(pool).await.map_err(adapter_common::map_sqlx_error)?;
+    let rows = q
+        .fetch_all(pool)
+        .await
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let mut map: HashMap<String, Vec<String>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(name);
     }
     Ok(map)
@@ -461,15 +517,28 @@ async fn fetch_cast_sqlite(
     for id in movie_ids {
         q = q.bind(id);
     }
-    let rows = q.fetch_all(pool).await.map_err(adapter_common::map_sqlx_error)?;
+    let rows = q
+        .fetch_all(pool)
+        .await
+        .map_err(adapter_common::map_sqlx_error)?;
 
     let mut map: HashMap<String, Vec<CastEntry>> = HashMap::new();
     for row in rows {
-        let mid: String = row.try_get("movie_id").map_err(adapter_common::map_sqlx_error)?;
+        let mid: String = row
-        let name: String = row.try_get("name").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("movie_id")
-        let billing_order: i32 = row.try_get("billing_order").map_err(adapter_common::map_sqlx_error)?;
+            .map_err(adapter_common::map_sqlx_error)?;
-        let tmdb_person_id: i64 = row.try_get("tmdb_person_id").map_err(adapter_common::map_sqlx_error)?;
+        let name: String = row
-        let profile_path: Option<String> = row.try_get("profile_path").map_err(adapter_common::map_sqlx_error)?;
+            .try_get("name")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let billing_order: i32 = row
+            .try_get("billing_order")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let tmdb_person_id: i64 = row
+            .try_get("tmdb_person_id")
+            .map_err(adapter_common::map_sqlx_error)?;
+        let profile_path: Option<String> = row
+            .try_get("profile_path")
+            .map_err(adapter_common::map_sqlx_error)?;
         map.entry(mid).or_default().push(CastEntry {
             name,
             billing_order: billing_order as u32,

crates/application/src/diary/deps.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use domain::ports::{
-    DiaryQuery, EventPublisher, MovieCommand, MovieProfileRepository, MovieQuery,
+    DiaryQuery, EventPublisher, MovieCommand, MovieProfileRepository, MovieQuery, ReviewRepository,
-    ReviewRepository, SocialQueryPort,
+    SocialQueryPort,
 };
 
 use crate::config::AppConfig;

crates/application/src/goals/create.rs

@@ -13,7 +13,10 @@ pub async fn execute(
 ) -> Result<GoalWithProgress, DomainError> {
     let user_id = UserId::from_uuid(cmd.user_id);
 
-    let existing = deps.goal_query.find_by_user_and_year(&user_id, cmd.year).await?;
+    let existing = deps
+        .goal_query
+        .find_by_user_and_year(&user_id, cmd.year)
+        .await?;
     if existing.is_some() {
         return Err(DomainError::ValidationError(
             "Goal already exists for this year".into(),

crates/application/src/test_helpers.rs

@@ -5,13 +5,13 @@ use domain::testing::{
 };
 use domain::{
     ports::{
-        AuthService, DiaryExporter, DiaryQuery, DocumentParser, EventPublisher,
+        AuthService, DiaryExporter, DiaryQuery, DocumentParser, EventPublisher, GoalCommand,
-        GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository, MetadataClient,
+        GoalQuery, ImportProfileRepository, ImportSessionRepository, MetadataClient, MovieCommand,
-        MovieCommand, MovieProfileRepository, MovieQuery, ObjectStorage, PasswordHasher,
+        MovieProfileRepository, MovieQuery, ObjectStorage, PasswordHasher, PersonCommand,
-        PersonCommand, PersonQuery, PosterFetcherClient, RefreshSessionRepository,
+        PersonQuery, PosterFetcherClient, RefreshSessionRepository, ReviewRepository,
-        ReviewRepository, SearchCommand, SearchPort, StatsRepository, UserProfileFieldsRepository,
+        SearchCommand, SearchPort, StatsRepository, UserProfileFieldsRepository, UserRepository,
-        UserRepository, UserSettingsRepository, WatchEventCommand, WatchEventQuery,
+        UserSettingsRepository, WatchEventCommand, WatchEventQuery, WatchlistRepository,
-        WatchlistRepository, WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
+        WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
     },
     testing::{
         FakeAuthService, FakeDiaryQuery, FakeDocumentParser, FakeMetadataClient,

crates/application/src/users/deps.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
 use domain::ports::{
-    DiaryQuery, EventPublisher, ObjectStorage, SocialQueryPort, StatsRepository,
+    DiaryQuery, EventPublisher, ObjectStorage, SocialQueryPort, StatsRepository, UserRepository,
-    UserRepository,
 };
 
 pub struct GetProfileDeps {

crates/domain/src/models/mod.rs

@@ -40,6 +40,7 @@ pub use watch_event::{
 pub use watchlist::{WatchlistEntry, WatchlistWithMovie};
 pub use wrapup::*;
 
+pub use crate::value_objects::PersonId;
 pub use import::{
     AnnotatedRow, DomainField, FieldMapping, FileFormat, ImportError, ImportRow, ParsedFile,
     RowResult, Transform,
@@ -49,7 +50,6 @@ pub use import_session::ImportSession;
 pub use person::{
     CastCredit, CrewCredit, ExternalPersonId, Person, PersonCredits, PersonEnrichmentData,
 };
-pub use crate::value_objects::PersonId;
 pub use refresh_session::{GeneratedToken, RefreshSession};
 pub use search::{
     EntityType, IndexableDocument, MovieSearchHit, PersonSearchHit, SearchFilters, SearchQuery,

crates/domain/src/ports/noop.rs

@@ -39,10 +39,7 @@ pub struct NoopSocialQueryPort;
 
 #[async_trait]
 impl super::SocialQueryPort for NoopSocialQueryPort {
-    async fn get_accepted_following_urls(
+    async fn get_accepted_following_urls(&self, _: &UserId) -> Result<Vec<String>, DomainError> {
-        &self,
-        _: &UserId,
-    ) -> Result<Vec<String>, DomainError> {
         Ok(vec![])
     }
     async fn list_all_followed_remote_actors(

crates/domain/src/value_objects/ids.rs

@@ -48,6 +48,9 @@ impl PersonId {
     /// Deterministic UUIDv5 from an external person ID string.
     /// "tmdb:12345" always maps to the same PersonId.
     pub fn from_external(external_id: &crate::models::person::ExternalPersonId) -> Self {
-        Self(Uuid::new_v5(&Uuid::NAMESPACE_URL, external_id.value().as_bytes()))
+        Self(Uuid::new_v5(
+            &Uuid::NAMESPACE_URL,
+            external_id.value().as_bytes(),
+        ))
     }
 }

crates/presentation/src/context.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use domain::ports::{
-    AuthService, DiaryExporter, DiaryQuery, DocumentParser, EventPublisher,
+    AuthService, DiaryExporter, DiaryQuery, DocumentParser, EventPublisher, FederatedProfileQuery,
-    FederatedProfileQuery, GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository,
+    GoalCommand, GoalQuery, ImportProfileRepository, ImportSessionRepository, MetadataClient,
-    MetadataClient, MovieCommand, MovieProfileRepository, MovieQuery, ObjectStorage,
+    MovieCommand, MovieProfileRepository, MovieQuery, ObjectStorage, PasswordHasher, PersonCommand,
-    PasswordHasher, PersonCommand, PersonEnrichmentClient, PersonQuery, PosterFetcherClient,
+    PersonEnrichmentClient, PersonQuery, PosterFetcherClient, RefreshSessionRepository,
-    RefreshSessionRepository, RemoteGoalRepository, RemoteWatchlistRepository, ReviewRepository,
+    RemoteGoalRepository, RemoteWatchlistRepository, ReviewRepository, SearchCommand, SearchPort,
-    SearchCommand, SearchPort, SocialQueryPort, StatsRepository, UserProfileFieldsRepository,
+    SocialQueryPort, StatsRepository, UserProfileFieldsRepository, UserRepository,
-    UserRepository, UserSettingsRepository, WatchEventCommand, WatchEventQuery,
+    UserSettingsRepository, WatchEventCommand, WatchEventQuery, WatchlistRepository,
-    WatchlistRepository, WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
+    WebhookTokenRepository, WrapUpRepository, WrapUpStatsQuery,
 };
 
 use application::config::AppConfig;

crates/presentation/src/handlers/users.rs

@@ -612,9 +612,7 @@ async fn fetch_profile_goals(
             goal_query: state.app_ctx.repos.goal_query.clone(),
             stats: state.app_ctx.repos.stats.clone(),
         },
-        application::goals::queries::ListGoalsQuery {
+        application::goals::queries::ListGoalsQuery { user_id },
-            user_id,
-        },
     )
     .await
     .unwrap_or_default();