fmt

crates/adapters/activitypub/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod composite_handler;
-pub mod social_adapter;
 pub mod event_handler;
 pub mod federation_event_bridge;
 pub mod goal_handler;
@@ -7,6 +6,7 @@ pub mod objects;
 pub mod port;
 pub mod remote_review_repository;
 pub mod review_handler;
+pub mod social_adapter;
 pub(crate) mod urls;
 pub mod user_adapter;
 pub mod watchlist_handler;

crates/adapters/activitypub/src/social_adapter.rs

@@ -87,11 +87,7 @@ fn ap_err(e: anyhow::Error) -> DomainError {
 
 #[async_trait]
 impl SocialCommand for CompositeSocialAdapter {
-    async fn follow(
+    async fn follow(&self, follower: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         if let SocialIdentity::Local(target_id) = target
             && follower == target_id
         {
@@ -154,11 +150,7 @@ impl SocialCommand for CompositeSocialAdapter {
             .map_err(ap_err)
     }
 
-    async fn block(
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         let actor_url = self.actor_url_from_identity(target);
         self.ap_service
             .block_actor(blocker.value(), &actor_url)
@@ -166,11 +158,7 @@ impl SocialCommand for CompositeSocialAdapter {
             .map_err(ap_err)
     }
 
-    async fn unblock(
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         let actor_url = self.actor_url_from_identity(target);
         self.ap_service
             .unblock_actor(blocker.value(), &actor_url)
@@ -181,10 +169,7 @@ impl SocialCommand for CompositeSocialAdapter {
 
 #[async_trait]
 impl SocialQuery for CompositeSocialAdapter {
-    async fn get_following(
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let actors = self
             .ap_service
             .get_following(user.value())
@@ -196,10 +181,7 @@ impl SocialQuery for CompositeSocialAdapter {
             .collect())
     }
 
-    async fn get_followers(
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let actors = self
             .ap_service
             .get_accepted_followers(user.value())
@@ -211,10 +193,7 @@ impl SocialQuery for CompositeSocialAdapter {
             .collect())
     }
 
-    async fn get_pending_followers(
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let actors = self
             .ap_service
             .get_pending_followers(user.value())
@@ -240,10 +219,7 @@ impl SocialQuery for CompositeSocialAdapter {
             .map_err(ap_err)
     }
 
-    async fn get_blocked(
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let actors = self
             .ap_service
             .get_blocked_actors(user.value())

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

@@ -1,9 +1,5 @@
 use async_trait::async_trait;
-use domain::{
+use domain::{errors::DomainError, models::RemoteActorInfo, ports::FederationAdminQuery};
-    errors::DomainError,
-    models::RemoteActorInfo,
-    ports::FederationAdminQuery,
-};
 
 use super::PostgresFederationRepository;
 

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

@@ -1,9 +1,5 @@
 use async_trait::async_trait;
-use domain::{
+use domain::{errors::DomainError, models::RemoteActorInfo, ports::FederationAdminQuery};
-    errors::DomainError,
-    models::RemoteActorInfo,
-    ports::FederationAdminQuery,
-};
 
 use super::SqliteFederationRepository;
 

crates/application/src/social/get_blocked.rs

@@ -1,4 +1,7 @@
-use domain::{errors::DomainError, value_objects::{SocialActor, UserId}};
+use domain::{
+    errors::DomainError,
+    value_objects::{SocialActor, UserId},
+};
 
 use super::{deps::SocialQueryDeps, queries::GetBlockedQuery};
 

crates/application/src/social/get_followers.rs

@@ -1,4 +1,7 @@
-use domain::{errors::DomainError, value_objects::{SocialActor, UserId}};
+use domain::{
+    errors::DomainError,
+    value_objects::{SocialActor, UserId},
+};
 
 use super::{deps::SocialQueryDeps, queries::GetFollowersQuery};
 

crates/application/src/social/get_following.rs

@@ -1,4 +1,7 @@
-use domain::{errors::DomainError, value_objects::{SocialActor, UserId}};
+use domain::{
+    errors::DomainError,
+    value_objects::{SocialActor, UserId},
+};
 
 use super::{deps::SocialQueryDeps, queries::GetFollowingQuery};
 

crates/application/src/social/get_pending.rs

@@ -1,4 +1,7 @@
-use domain::{errors::DomainError, value_objects::{SocialActor, UserId}};
+use domain::{
+    errors::DomainError,
+    value_objects::{SocialActor, UserId},
+};
 
 use super::{deps::SocialQueryDeps, queries::GetPendingFollowersQuery};
 

crates/application/src/social/tests/accept.rs

@@ -14,7 +14,11 @@ use crate::social::{
     follow,
 };
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -53,7 +57,9 @@ async fn accept_follow_emits_follow_accepted_event() {
     .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::FollowAccepted { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowAccepted { .. }))
+    );
 }

crates/application/src/social/tests/block.rs

@@ -9,7 +9,11 @@ use uuid::Uuid;
 
 use crate::social::{block, commands::BlockCommand, deps::SocialCommandDeps};
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -35,7 +39,9 @@ async fn block_emits_actor_blocked_event() {
     .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::ActorBlocked { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::ActorBlocked { .. }))
+    );
 }

crates/application/src/social/tests/follow.rs

@@ -9,7 +9,11 @@ use uuid::Uuid;
 
 use crate::social::{commands::FollowCommand, deps::SocialCommandDeps, follow};
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -35,9 +39,11 @@ async fn follow_emits_follow_requested_event() {
     .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::FollowRequested { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowRequested { .. }))
+    );
 }
 
 #[tokio::test]

crates/application/src/social/tests/get_followers.rs

@@ -50,13 +50,8 @@ async fn returns_accepted_followers() {
     .await
     .unwrap();
 
-    let followers = get_followers::execute(
+    let followers = get_followers::execute(&query_deps, GetFollowersQuery { user_id: owner_id })
-        &query_deps,
+        .await
-        GetFollowersQuery {
+        .unwrap();
-            user_id: owner_id,
-        },
-    )
-    .await
-    .unwrap();
     assert_eq!(followers.len(), 1);
 }

crates/application/src/social/tests/get_pending.rs

@@ -39,13 +39,8 @@ async fn returns_only_pending_followers() {
     .await
     .unwrap();
 
-    let pending = get_pending::execute(
+    let pending = get_pending::execute(&query_deps, GetPendingFollowersQuery { user_id: owner_id })
-        &query_deps,
+        .await
-        GetPendingFollowersQuery {
+        .unwrap();
-            user_id: owner_id,
-        },
-    )
-    .await
-    .unwrap();
     assert_eq!(pending.len(), 1);
 }

crates/application/src/social/tests/reject.rs

@@ -12,7 +12,11 @@ use crate::social::{
     follow, reject,
 };
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {

crates/application/src/social/tests/remove_follower.rs

@@ -14,7 +14,11 @@ use crate::social::{
     follow, remove_follower,
 };
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -62,7 +66,9 @@ async fn remove_follower_emits_follower_removed_event() {
     .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::FollowerRemoved { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::FollowerRemoved { .. }))
+    );
 }

crates/application/src/social/tests/unblock.rs

@@ -8,12 +8,17 @@ use domain::{
 use uuid::Uuid;
 
 use crate::social::{
+    block,
     commands::{BlockCommand, UnblockCommand},
     deps::SocialCommandDeps,
-    block, unblock,
+    unblock,
 };
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -40,18 +45,14 @@ async fn unblock_emits_actor_unblocked_event() {
     .await
     .unwrap();
 
-    unblock::execute(
+    unblock::execute(&deps, UnblockCommand { blocker_id, target })
-        &deps,
+        .await
-        UnblockCommand {
+        .unwrap();
-            blocker_id,
-            target,
-        },
-    )
-    .await
-    .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::ActorUnblocked { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::ActorUnblocked { .. }))
+    );
 }

crates/application/src/social/tests/unfollow.rs

@@ -13,7 +13,11 @@ use crate::social::{
     follow, unfollow,
 };
 
-fn make_deps() -> (Arc<InMemorySocialRepository>, Arc<NoopEventPublisher>, SocialCommandDeps) {
+fn make_deps() -> (
+    Arc<InMemorySocialRepository>,
+    Arc<NoopEventPublisher>,
+    SocialCommandDeps,
+) {
     let social = InMemorySocialRepository::new();
     let events = NoopEventPublisher::new();
     let deps = SocialCommandDeps {
@@ -51,7 +55,9 @@ async fn unfollow_emits_unfollowed_event() {
     .unwrap();
 
     let published = events.published();
-    assert!(published
+    assert!(
-        .iter()
+        published
-        .any(|e| matches!(e, DomainEvent::Unfollowed { .. })));
+            .iter()
+            .any(|e| matches!(e, DomainEvent::Unfollowed { .. }))
+    );
 }

crates/application/src/social/unfollow.rs

@@ -4,9 +4,7 @@ use super::{commands::UnfollowCommand, deps::SocialCommandDeps};
 
 pub async fn execute(deps: &SocialCommandDeps, cmd: UnfollowCommand) -> Result<(), DomainError> {
     let follower = UserId::from_uuid(cmd.follower_id);
-    deps.social_command
+    deps.social_command.unfollow(&follower, &cmd.target).await?;
-        .unfollow(&follower, &cmd.target)
-        .await?;
     deps.event_publisher
         .publish(&DomainEvent::Unfollowed {
             follower,

crates/domain/src/ports/social.rs

@@ -4,8 +4,8 @@ use chrono::NaiveDateTime;
 use crate::{
     errors::DomainError,
     models::{
-        DiaryEntry, FederationFlags, RemoteActorInfo, RemoteGoalEntry,
+        DiaryEntry, FederationFlags, RemoteActorInfo, RemoteGoalEntry, RemoteWatchlistEntry,
-        RemoteWatchlistEntry, WatchlistWithMovie,
+        WatchlistWithMovie,
     },
     value_objects::{MovieId, SocialActor, SocialIdentity, UserId},
 };
@@ -14,17 +14,10 @@ use crate::{
 
 #[async_trait]
 pub trait SocialCommand: Send + Sync {
-    async fn follow(
+    async fn follow(&self, follower: &UserId, target: &SocialIdentity) -> Result<(), DomainError>;
-        &self,
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError>;
 
-    async fn unfollow(
+    async fn unfollow(&self, follower: &UserId, target: &SocialIdentity)
-        &self,
+    -> Result<(), DomainError>;
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError>;
 
     async fn accept_follow(
         &self,
@@ -44,44 +37,24 @@ pub trait SocialCommand: Send + Sync {
         follower: &SocialIdentity,
     ) -> Result<(), DomainError>;
 
-    async fn block(
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError>;
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError>;
 
-    async fn unblock(
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError>;
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError>;
 }
 
 #[async_trait]
 pub trait SocialQuery: Send + Sync {
-    async fn get_following(
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError>;
 
-    async fn get_followers(
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError>;
 
-    async fn get_pending_followers(
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError>;
 
     async fn count_following(&self, user: &UserId) -> Result<usize, DomainError>;
 
     async fn count_followers(&self, user: &UserId) -> Result<usize, DomainError>;
 
-    async fn get_blocked(
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError>;
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError>;
 
     async fn is_following(
         &self,
@@ -93,7 +66,6 @@ pub trait SocialQuery: Send + Sync {
         &self,
         user_id: &UserId,
     ) -> Result<Vec<String>, DomainError>;
-
 }
 
 #[async_trait]

crates/domain/src/testing/in_memory.rs

@@ -893,11 +893,7 @@ impl InMemorySocialRepository {
 
 #[async_trait]
 impl SocialCommand for InMemorySocialRepository {
-    async fn follow(
+    async fn follow(&self, follower: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         if let SocialIdentity::Local(target_id) = target {
             if follower == target_id {
                 return Err(DomainError::ValidationError(
@@ -925,7 +921,9 @@ impl SocialCommand for InMemorySocialRepository {
         let before = store.len();
         store.retain(|(f, t, _)| !(*f == follower.value() && t == target));
         if store.len() == before {
-            return Err(DomainError::NotFound("Follow relationship not found".into()));
+            return Err(DomainError::NotFound(
+                "Follow relationship not found".into(),
+            ));
         }
         Ok(())
     }
@@ -1008,11 +1006,7 @@ impl SocialCommand for InMemorySocialRepository {
         Ok(())
     }
 
-    async fn block(
+    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         let mut store = self.blocked.lock().unwrap();
         store.push((blocker.value(), target.clone()));
         // Also remove any existing follow relationships
@@ -1021,11 +1015,7 @@ impl SocialCommand for InMemorySocialRepository {
         Ok(())
     }
 
-    async fn unblock(
+    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        &self,
-        blocker: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
         let mut store = self.blocked.lock().unwrap();
         store.retain(|(b, t)| !(*b == blocker.value() && t == target));
         Ok(())
@@ -1034,10 +1024,7 @@ impl SocialCommand for InMemorySocialRepository {
 
 #[async_trait]
 impl SocialQuery for InMemorySocialRepository {
-    async fn get_following(
+    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let store = self.follows.lock().unwrap();
         Ok(store
             .iter()
@@ -1046,10 +1033,7 @@ impl SocialQuery for InMemorySocialRepository {
             .collect())
     }
 
-    async fn get_followers(
+    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let store = self.follows.lock().unwrap();
         let target = SocialIdentity::Local(user.clone());
         Ok(store
@@ -1062,10 +1046,7 @@ impl SocialQuery for InMemorySocialRepository {
             .collect())
     }
 
-    async fn get_pending_followers(
+    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let store = self.follows.lock().unwrap();
         let target = SocialIdentity::Local(user.clone());
         Ok(store
@@ -1095,10 +1076,7 @@ impl SocialQuery for InMemorySocialRepository {
             .count())
     }
 
-    async fn get_blocked(
+    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        &self,
-        user: &UserId,
-    ) -> Result<Vec<SocialActor>, DomainError> {
         let store = self.blocked.lock().unwrap();
         Ok(store
             .iter()
@@ -1113,9 +1091,9 @@ impl SocialQuery for InMemorySocialRepository {
         target: &SocialIdentity,
     ) -> Result<bool, DomainError> {
         let store = self.follows.lock().unwrap();
-        Ok(store
+        Ok(store.iter().any(|(f, t, state)| {
-            .iter()
+            *f == follower.value() && t == target && *state == FollowState::Accepted
-            .any(|(f, t, state)| *f == follower.value() && t == target && *state == FollowState::Accepted))
+        }))
     }
 
     async fn get_accepted_following_urls(

crates/domain/src/testing/noops.rs

@@ -64,8 +64,8 @@ impl ObjectStorage for NoopObjectStorage {
 
 // Re-export production noop types so test code that imports from
 // `domain::testing` keeps compiling without changes.
-pub use crate::ports::noop::NoopRemoteWatchlistRepository;
 pub use crate::ports::noop::NoopFederationAdminQuery;
+pub use crate::ports::noop::NoopRemoteWatchlistRepository;
 
 // ── NoopGoalCommand ───────────────────────────────────────────────────────────
 

crates/domain/src/testing/panics.rs

@@ -6,8 +6,8 @@ use crate::{
         AnnotatedRow, DiaryEntry, DiaryFilter, EntityType, ExportFormat, ExternalPersonId,
         FeedEntry, FeedSortBy, FieldMapping, FileFormat, FollowingFilter, ImportError,
         ImportProfile, ImportSession, IndexableDocument, MovieProfile, MovieStats, ParsedFile,
-        Person, PersonCredits, PersonEnrichmentData, PersonId, RefreshSession,
+        Person, PersonCredits, PersonEnrichmentData, PersonId, RefreshSession, RemoteActorInfo,
-        RemoteActorInfo, ReviewHistory, SearchQuery, SearchResults, UserStats, UserTrends,
+        ReviewHistory, SearchQuery, SearchResults, UserStats, UserTrends,
         collections::{PageParams, Paginated},
     },
     ports::{

crates/presentation/src/context.rs

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

crates/presentation/src/handlers/social.rs

@@ -84,7 +84,9 @@ pub async fn get_blocked_domains_admin(
     _admin: AdminApiUser,
 ) -> Result<Json<Vec<BlockedDomainResponse>>, ApiError> {
     let domains = state
-        .app_ctx.services.ap_service
+        .app_ctx
+        .services
+        .ap_service
         .get_blocked_domains()
         .await
         .map_err(ap_to_domain)?;
@@ -116,7 +118,9 @@ pub async fn add_blocked_domain_admin(
     axum::Json(body): axum::Json<AddBlockedDomainRequest>,
 ) -> Result<impl IntoResponse, ApiError> {
     state
-        .app_ctx.services.ap_service
+        .app_ctx
+        .services
+        .ap_service
         .add_blocked_domain(&body.domain, body.reason.as_deref())
         .await
         .map_err(ap_to_domain)?;
@@ -139,7 +143,9 @@ pub async fn remove_blocked_domain_admin(
     axum::extract::Path(domain): axum::extract::Path<String>,
 ) -> Result<impl IntoResponse, ApiError> {
     state
-        .app_ctx.services.ap_service
+        .app_ctx
+        .services
+        .ap_service
         .remove_blocked_domain(&domain)
         .await
         .map_err(ap_to_domain)?;
@@ -263,10 +269,7 @@ pub async fn get_following(
     )
     .await?;
     Ok(Json(ActorListResponse {
-        actors: identities
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
-            .into_iter()
-            .map(social_actor_to_dto)
-            .collect(),
     }))
 }
 
@@ -293,10 +296,7 @@ pub async fn get_followers(
     )
     .await?;
     Ok(Json(ActorListResponse {
-        actors: identities
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
-            .into_iter()
-            .map(social_actor_to_dto)
-            .collect(),
     }))
 }
 
@@ -314,10 +314,7 @@ pub async fn get_user_following(
     )
     .await?;
     Ok(Json(ActorListResponse {
-        actors: identities
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
-            .into_iter()
-            .map(social_actor_to_dto)
-            .collect(),
     }))
 }
 
@@ -335,10 +332,7 @@ pub async fn get_user_followers(
     )
     .await?;
     Ok(Json(ActorListResponse {
-        actors: identities
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
-            .into_iter()
-            .map(social_actor_to_dto)
-            .collect(),
     }))
 }
 
@@ -525,10 +519,7 @@ pub async fn get_pending_followers(
     )
     .await?;
     Ok(Json(ActorListResponse {
-        actors: identities
+        actors: identities.into_iter().map(social_actor_to_dto).collect(),
-            .into_iter()
-            .map(social_actor_to_dto)
-            .collect(),
     }))
 }
 
@@ -563,7 +554,9 @@ pub async fn follow_remote_user(
         &deps,
         application::social::commands::FollowCommand {
             follower_id: user_id.value(),
-            target: SocialIdentity::Remote { actor_url: form.handle },
+            target: SocialIdentity::Remote {
+                actor_url: form.handle,
+            },
         },
     )
     .await
@@ -604,7 +597,9 @@ pub async fn unfollow_remote_user(
         &deps,
         application::social::commands::UnfollowCommand {
             follower_id: user_id.value(),
-            target: SocialIdentity::Remote { actor_url: form.actor_url },
+            target: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await
@@ -645,7 +640,9 @@ pub async fn accept_follower_html(
         &deps,
         application::social::commands::AcceptFollowCommand {
             owner_id: user_id.value(),
-            requester: SocialIdentity::Remote { actor_url: form.actor_url },
+            requester: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await
@@ -680,7 +677,9 @@ pub async fn reject_follower_html(
         &deps,
         application::social::commands::RejectFollowCommand {
             owner_id: user_id.value(),
-            requester: SocialIdentity::Remote { actor_url: form.actor_url },
+            requester: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await
@@ -706,7 +705,9 @@ pub async fn get_followers_collection(
     if accept.contains("application/activity+json") || accept.contains("application/ld+json") {
         let page = params.get("page").and_then(|p| p.parse::<u32>().ok());
         return match state
-            .app_ctx.services.ap_service
+            .app_ctx
+            .services
+            .ap_service
             .followers_collection_json(user_id, page)
             .await
         {
@@ -737,7 +738,9 @@ pub async fn get_following_collection(
     if accept.contains("application/activity+json") || accept.contains("application/ld+json") {
         let page = params.get("page").and_then(|p| p.parse::<u32>().ok());
         return match state
-            .app_ctx.services.ap_service
+            .app_ctx
+            .services
+            .ap_service
             .following_collection_json(user_id, page)
             .await
         {
@@ -776,7 +779,9 @@ pub async fn get_following_page(
     };
     match application::social::get_following::execute(
         &deps,
-        application::social::queries::GetFollowingQuery { user_id: user_id.value() },
+        application::social::queries::GetFollowingQuery {
+            user_id: user_id.value(),
+        },
     )
     .await
     {
@@ -825,7 +830,9 @@ pub async fn get_followers_page(
     };
     match application::social::get_followers::execute(
         &deps,
-        application::social::queries::GetFollowersQuery { user_id: user_id.value() },
+        application::social::queries::GetFollowersQuery {
+            user_id: user_id.value(),
+        },
     )
     .await
     {
@@ -875,7 +882,9 @@ pub async fn remove_follower_html(
         &deps,
         application::social::commands::RemoveFollowerCommand {
             owner_id: user_id.value(),
-            follower: SocialIdentity::Remote { actor_url: form.actor_url },
+            follower: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await
@@ -902,7 +911,13 @@ pub async fn get_blocked_domains_page(
     let mut ctx = build_page_context(&state, Some(user_id), csrf.0).await;
     ctx.page_title = "Blocked Domains — Movies Diary".to_string();
     ctx.canonical_url = format!("{}/admin/blocked-domains", state.app_ctx.config.base_url);
-    match state.app_ctx.services.ap_service.get_blocked_domains().await {
+    match state
+        .app_ctx
+        .services
+        .ap_service
+        .get_blocked_domains()
+        .await
+    {
         Ok(domains) => {
             let entries: Vec<template_askama::BlockedDomainEntry> = domains
                 .into_iter()
@@ -940,7 +955,9 @@ pub async fn post_blocked_domain(
     }
     let reason = form.reason.as_deref().filter(|s| !s.trim().is_empty());
     match state
-        .app_ctx.services.ap_service
+        .app_ctx
+        .services
+        .ap_service
         .add_blocked_domain(&form.domain, reason)
         .await
     {
@@ -961,7 +978,13 @@ pub async fn post_remove_blocked_domain(
     if crate::csrf::mismatch(&csrf, &form.csrf_token) {
         return StatusCode::FORBIDDEN.into_response();
     }
-    match state.app_ctx.services.ap_service.remove_blocked_domain(&form.domain).await {
+    match state
+        .app_ctx
+        .services
+        .ap_service
+        .remove_blocked_domain(&form.domain)
+        .await
+    {
         Ok(()) => Redirect::to("/admin/blocked-domains").into_response(),
         Err(e) => {
             tracing::error!("remove_blocked_domain error: {:?}", e);
@@ -983,7 +1006,9 @@ pub async fn get_blocked_actors_page(
     };
     match application::social::get_blocked::execute(
         &deps,
-        application::social::queries::GetBlockedQuery { user_id: user_id.value() },
+        application::social::queries::GetBlockedQuery {
+            user_id: user_id.value(),
+        },
     )
     .await
     {
@@ -1032,7 +1057,9 @@ pub async fn post_block_actor_html(
         &deps,
         application::social::commands::BlockCommand {
             blocker_id: user_id.value(),
-            target: SocialIdentity::Remote { actor_url: form.actor_url },
+            target: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await
@@ -1063,7 +1090,9 @@ pub async fn post_unblock_actor(
         &deps,
         application::social::commands::UnblockCommand {
             blocker_id: user_id.value(),
-            target: SocialIdentity::Remote { actor_url: form.actor_url },
+            target: SocialIdentity::Remote {
+                actor_url: form.actor_url,
+            },
         },
     )
     .await

crates/presentation/src/main.rs

@@ -66,7 +66,15 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
     let event_bus = EventBusBackend::from_env()?;
 
     #[cfg(feature = "federation")]
-    let (event_publisher_arc, ap_router, ap_service, social_query, remote_watchlist_repo, social_command_arc, social_query_unified_arc) = {
+    let (
+        event_publisher_arc,
+        ap_router,
+        ap_service,
+        social_query,
+        remote_watchlist_repo,
+        social_command_arc,
+        social_query_unified_arc,
+    ) = {
         let (
             activity_repo,
             follow_repo,

crates/worker/src/follow_backfill_handler.rs

@@ -1,7 +1,9 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use domain::{errors::DomainError, events::DomainEvent, ports::EventHandler, value_objects::SocialIdentity};
+use domain::{
+    errors::DomainError, events::DomainEvent, ports::EventHandler, value_objects::SocialIdentity,
+};
 
 pub struct FollowBackfillHandler {
     pub ap_service: Arc<dyn activitypub::ActivityPubPort>,