Refactor handlers and OpenAPI documentation for improved readability and consistency

- Reorganized imports in health, notifications, social, thoughts, and users handlers for clarity.
- Updated function signatures in handlers to improve readability by aligning parameters.
- Enhanced JSON response formatting in notifications and thoughts handlers.
- Improved error handling in user-related functions.
- Refactored OpenAPI documentation to maintain consistent formatting and structure.
- Cleaned up unnecessary code and comments across various files.
- Ensured consistent use of `Arc` for shared state in AppState and WorkerHandlers.

crates/application/src/services/federation_event.rs

@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
@@ -6,55 +5,91 @@ use domain::{
     ports::{OutboundFederationPort, ThoughtRepository, UserRepository},
     value_objects::ThoughtId,
 };
+use std::sync::Arc;
 
 pub struct FederationEventService {
-    pub thoughts:  Arc<dyn ThoughtRepository>,
-    pub users:     Arc<dyn UserRepository>,
-    pub ap:        Arc<dyn OutboundFederationPort>,
-    pub base_url:  String,
+    pub thoughts: Arc<dyn ThoughtRepository>,
+    pub users: Arc<dyn UserRepository>,
+    pub ap: Arc<dyn OutboundFederationPort>,
+    pub base_url: String,
 }
 
 impl FederationEventService {
     fn object_ap_id(&self, thought: &Thought, thought_id: &ThoughtId) -> String {
-        thought.ap_id.clone().unwrap_or_else(|| {
-            format!("{}/thoughts/{}", self.base_url, thought_id)
-        })
+        thought
+            .ap_id
+            .clone()
+            .unwrap_or_else(|| format!("{}/thoughts/{}", self.base_url, thought_id))
     }
 
     pub async fn process(&self, event: &DomainEvent) -> Result<(), DomainError> {
         match event {
-            DomainEvent::ThoughtCreated { thought_id, user_id, .. } => {
+            DomainEvent::ThoughtCreated {
+                thought_id,
+                user_id,
+                ..
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
-                    Some(t) if t.local && matches!(t.visibility, Visibility::Public | Visibility::Unlisted) => t,
+                    Some(t)
+                        if t.local
+                            && matches!(
+                                t.visibility,
+                                Visibility::Public | Visibility::Unlisted
+                            ) =>
+                    {
+                        t
+                    }
                     _ => return Ok(()),
                 };
                 let user = match self.users.find_by_id(user_id).await? {
                     Some(u) => u,
                     None => return Ok(()),
                 };
-                self.ap.broadcast_create(user_id, &thought, user.username.as_str()).await
+                self.ap
+                    .broadcast_create(user_id, &thought, user.username.as_str())
+                    .await
             }
 
-            DomainEvent::ThoughtDeleted { thought_id, user_id } => {
+            DomainEvent::ThoughtDeleted {
+                thought_id,
+                user_id,
+            } => {
                 // No DB lookup — thought is already deleted when this event fires.
                 // No locality guard: delete commands only reach local thoughts via the use case.
                 let ap_id = format!("{}/thoughts/{}", self.base_url, thought_id);
                 self.ap.broadcast_delete(user_id, &ap_id).await
             }
 
-            DomainEvent::ThoughtUpdated { thought_id, user_id } => {
+            DomainEvent::ThoughtUpdated {
+                thought_id,
+                user_id,
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
-                    Some(t) if t.local && matches!(t.visibility, Visibility::Public | Visibility::Unlisted) => t,
+                    Some(t)
+                        if t.local
+                            && matches!(
+                                t.visibility,
+                                Visibility::Public | Visibility::Unlisted
+                            ) =>
+                    {
+                        t
+                    }
                     _ => return Ok(()),
                 };
                 let user = match self.users.find_by_id(user_id).await? {
                     Some(u) => u,
                     None => return Ok(()),
                 };
-                self.ap.broadcast_update(user_id, &thought, user.username.as_str()).await
+                self.ap
+                    .broadcast_update(user_id, &thought, user.username.as_str())
+                    .await
             }
 
-            DomainEvent::BoostAdded { boost_id: _, user_id, thought_id } => {
+            DomainEvent::BoostAdded {
+                boost_id: _,
+                user_id,
+                thought_id,
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     None => return Ok(()),
@@ -63,13 +98,18 @@ impl FederationEventService {
                 self.ap.broadcast_announce(user_id, &object_ap_id).await
             }
 
-            DomainEvent::BoostRemoved { user_id, thought_id } => {
+            DomainEvent::BoostRemoved {
+                user_id,
+                thought_id,
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     None => return Ok(()),
                 };
                 let object_ap_id = self.object_ap_id(&thought, thought_id);
-                self.ap.broadcast_undo_announce(user_id, &object_ap_id).await
+                self.ap
+                    .broadcast_undo_announce(user_id, &object_ap_id)
+                    .await
             }
 
             _ => Ok(()),
@@ -96,16 +136,21 @@ mod tests {
 
     #[derive(Default)]
     struct SpyPort {
-        created:        Mutex<Vec<ThoughtId>>,
-        deleted:        Mutex<Vec<String>>,
-        updated:        Mutex<Vec<ThoughtId>>,
-        announced:      Mutex<Vec<String>>,
+        created: Mutex<Vec<ThoughtId>>,
+        deleted: Mutex<Vec<String>>,
+        updated: Mutex<Vec<ThoughtId>>,
+        announced: Mutex<Vec<String>>,
         undo_announced: Mutex<Vec<String>>,
     }
 
     #[async_trait]
     impl OutboundFederationPort for SpyPort {
-        async fn broadcast_create(&self, _: &UserId, thought: &Thought, _: &str) -> Result<(), DomainError> {
+        async fn broadcast_create(
+            &self,
+            _: &UserId,
+            thought: &Thought,
+            _: &str,
+        ) -> Result<(), DomainError> {
             self.created.lock().unwrap().push(thought.id.clone());
             Ok(())
         }
@@ -113,7 +158,12 @@ mod tests {
             self.deleted.lock().unwrap().push(ap_id.to_string());
             Ok(())
         }
-        async fn broadcast_update(&self, _: &UserId, thought: &Thought, _: &str) -> Result<(), DomainError> {
+        async fn broadcast_update(
+            &self,
+            _: &UserId,
+            thought: &Thought,
+            _: &str,
+        ) -> Result<(), DomainError> {
             self.updated.lock().unwrap().push(thought.id.clone());
             Ok(())
         }
@@ -121,7 +171,11 @@ mod tests {
             self.announced.lock().unwrap().push(ap_id.to_string());
             Ok(())
         }
-        async fn broadcast_undo_announce(&self, _: &UserId, ap_id: &str) -> Result<(), DomainError> {
+        async fn broadcast_undo_announce(
+            &self,
+            _: &UserId,
+            ap_id: &str,
+        ) -> Result<(), DomainError> {
             self.undo_announced.lock().unwrap().push(ap_id.to_string());
             Ok(())
         }
@@ -138,9 +192,13 @@ mod tests {
 
     fn local_thought(author_id: UserId) -> Thought {
         Thought::new_local(
-            ThoughtId::new(), author_id,
+            ThoughtId::new(),
+            author_id,
             Content::new_local("hello").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         )
     }
 
@@ -259,7 +317,10 @@ mod tests {
 
         let announced = spy.announced.lock().unwrap();
         assert_eq!(announced.len(), 1);
-        assert_eq!(announced[0], format!("https://example.com/thoughts/{}", thought.id));
+        assert_eq!(
+            announced[0],
+            format!("https://example.com/thoughts/{}", thought.id)
+        );
     }
 
     #[tokio::test]
@@ -282,7 +343,10 @@ mod tests {
             .unwrap();
 
         let announced = spy.announced.lock().unwrap();
-        assert_eq!(announced[0], "https://mastodon.social/users/bob/statuses/123");
+        assert_eq!(
+            announced[0],
+            "https://mastodon.social/users/bob/statuses/123"
+        );
     }
 
     #[tokio::test]
@@ -290,9 +354,13 @@ mod tests {
         let store = TestStore::default();
         let alice = alice();
         let thought = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("private").unwrap(),
-            None, Visibility::Direct, None, false,
+            None,
+            Visibility::Direct,
+            None,
+            false,
         );
         store.users.lock().unwrap().push(alice.clone());
         store.thoughts.lock().unwrap().push(thought.clone());
@@ -315,9 +383,13 @@ mod tests {
         let store = TestStore::default();
         let alice = alice();
         let thought = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("for followers").unwrap(),
-            None, Visibility::Followers, None, false,
+            None,
+            Visibility::Followers,
+            None,
+            false,
         );
         store.users.lock().unwrap().push(alice.clone());
         store.thoughts.lock().unwrap().push(thought.clone());
@@ -344,7 +416,9 @@ mod tests {
         svc.process(&DomainEvent::UserBlocked {
             blocker_id: UserId::new(),
             blocked_id: UserId::new(),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
 
         assert!(spy.created.lock().unwrap().is_empty());
         assert!(spy.deleted.lock().unwrap().is_empty());
@@ -391,7 +465,10 @@ mod tests {
 
         let undo_announced = spy.undo_announced.lock().unwrap();
         assert_eq!(undo_announced.len(), 1);
-        assert_eq!(undo_announced[0], format!("https://example.com/thoughts/{}", thought.id));
+        assert_eq!(
+            undo_announced[0],
+            format!("https://example.com/thoughts/{}", thought.id)
+        );
     }
 
     #[tokio::test]
@@ -414,7 +491,10 @@ mod tests {
 
         let undo_announced = spy.undo_announced.lock().unwrap();
         assert_eq!(undo_announced.len(), 1);
-        assert_eq!(undo_announced[0], "https://mastodon.social/users/bob/statuses/456");
+        assert_eq!(
+            undo_announced[0],
+            "https://mastodon.social/users/bob/statuses/456"
+        );
     }
 
     #[tokio::test]

crates/application/src/services/notification_event.rs

@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use chrono::Utc;
 use domain::{
     errors::DomainError,
@@ -7,9 +6,10 @@ use domain::{
     ports::{NotificationRepository, ThoughtRepository},
     value_objects::{NotificationId, UserId},
 };
+use std::sync::Arc;
 
 pub struct NotificationEventService {
-    pub thoughts:      Arc<dyn ThoughtRepository>,
+    pub thoughts: Arc<dyn ThoughtRepository>,
     pub notifications: Arc<dyn NotificationRepository>,
 }
 
@@ -20,50 +20,75 @@ fn is_self_action(thought_author: &UserId, actor: &UserId) -> bool {
 impl NotificationEventService {
     pub async fn process(&self, event: &DomainEvent) -> Result<(), DomainError> {
         match event {
-            DomainEvent::LikeAdded { like_id: _, user_id, thought_id } => {
+            DomainEvent::LikeAdded {
+                like_id: _,
+                user_id,
+                thought_id,
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     None => return Ok(()),
                 };
-                if is_self_action(&thought.user_id, user_id) { return Ok(()); }
-                self.notifications.save(&Notification {
-                    id: NotificationId::new(),
-                    user_id: thought.user_id,
-                    notification_type: NotificationType::Like,
-                    from_user_id: Some(user_id.clone()),
-                    thought_id: Some(thought_id.clone()),
-                    read: false,
-                    created_at: Utc::now(),
-                }).await
+                if is_self_action(&thought.user_id, user_id) {
+                    return Ok(());
+                }
+                self.notifications
+                    .save(&Notification {
+                        id: NotificationId::new(),
+                        user_id: thought.user_id,
+                        notification_type: NotificationType::Like,
+                        from_user_id: Some(user_id.clone()),
+                        thought_id: Some(thought_id.clone()),
+                        read: false,
+                        created_at: Utc::now(),
+                    })
+                    .await
             }
-            DomainEvent::BoostAdded { boost_id: _, user_id, thought_id } => {
+            DomainEvent::BoostAdded {
+                boost_id: _,
+                user_id,
+                thought_id,
+            } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     None => return Ok(()),
                 };
-                if is_self_action(&thought.user_id, user_id) { return Ok(()); }
-                self.notifications.save(&Notification {
-                    id: NotificationId::new(),
-                    user_id: thought.user_id,
-                    notification_type: NotificationType::Boost,
-                    from_user_id: Some(user_id.clone()),
-                    thought_id: Some(thought_id.clone()),
-                    read: false,
-                    created_at: Utc::now(),
-                }).await
+                if is_self_action(&thought.user_id, user_id) {
+                    return Ok(());
+                }
+                self.notifications
+                    .save(&Notification {
+                        id: NotificationId::new(),
+                        user_id: thought.user_id,
+                        notification_type: NotificationType::Boost,
+                        from_user_id: Some(user_id.clone()),
+                        thought_id: Some(thought_id.clone()),
+                        read: false,
+                        created_at: Utc::now(),
+                    })
+                    .await
             }
-            DomainEvent::FollowAccepted { follower_id, following_id } => {
-                self.notifications.save(&Notification {
-                    id: NotificationId::new(),
-                    user_id: following_id.clone(),
-                    notification_type: NotificationType::Follow,
-                    from_user_id: Some(follower_id.clone()),
-                    thought_id: None,
-                    read: false,
-                    created_at: Utc::now(),
-                }).await
+            DomainEvent::FollowAccepted {
+                follower_id,
+                following_id,
+            } => {
+                self.notifications
+                    .save(&Notification {
+                        id: NotificationId::new(),
+                        user_id: following_id.clone(),
+                        notification_type: NotificationType::Follow,
+                        from_user_id: Some(follower_id.clone()),
+                        thought_id: None,
+                        read: false,
+                        created_at: Utc::now(),
+                    })
+                    .await
             }
-            DomainEvent::ThoughtCreated { thought_id, user_id, in_reply_to_id } => {
+            DomainEvent::ThoughtCreated {
+                thought_id,
+                user_id,
+                in_reply_to_id,
+            } => {
                 let reply_to_id = match in_reply_to_id {
                     Some(id) => id,
                     None => return Ok(()),
@@ -72,16 +97,20 @@ impl NotificationEventService {
                     Some(t) => t,
                     None => return Ok(()),
                 };
-                if is_self_action(&original.user_id, user_id) { return Ok(()); }
-                self.notifications.save(&Notification {
-                    id: NotificationId::new(),
-                    user_id: original.user_id,
-                    notification_type: NotificationType::Reply,
-                    from_user_id: Some(user_id.clone()),
-                    thought_id: Some(thought_id.clone()),
-                    read: false,
-                    created_at: Utc::now(),
-                }).await
+                if is_self_action(&original.user_id, user_id) {
+                    return Ok(());
+                }
+                self.notifications
+                    .save(&Notification {
+                        id: NotificationId::new(),
+                        user_id: original.user_id,
+                        notification_type: NotificationType::Reply,
+                        from_user_id: Some(user_id.clone()),
+                        thought_id: Some(thought_id.clone()),
+                        read: false,
+                        created_at: Utc::now(),
+                    })
+                    .await
             }
             _ => Ok(()),
         }
@@ -92,7 +121,10 @@ impl NotificationEventService {
 mod tests {
     use super::*;
     use domain::{
-        models::{thought::{Thought, Visibility}, user::User},
+        models::{
+            thought::{Thought, Visibility},
+            user::User,
+        },
         testing::TestStore,
         value_objects::*,
     };
@@ -113,9 +145,13 @@ mod tests {
         let alice = alice();
         let bob_id = UserId::new();
         let thought = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("hello").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         );
         store.thoughts.lock().unwrap().push(thought.clone());
         let svc = NotificationEventService {
@@ -126,10 +162,15 @@ mod tests {
             like_id: LikeId::new(),
             user_id: bob_id,
             thought_id: thought.id.clone(),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         let notifs = store.notifications.lock().unwrap();
         assert_eq!(notifs.len(), 1);
-        assert!(matches!(notifs[0].notification_type, NotificationType::Like));
+        assert!(matches!(
+            notifs[0].notification_type,
+            NotificationType::Like
+        ));
     }
 
     #[tokio::test]
@@ -137,9 +178,13 @@ mod tests {
         let store = TestStore::default();
         let alice = alice();
         let thought = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("hello").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         );
         store.thoughts.lock().unwrap().push(thought.clone());
         let svc = NotificationEventService {
@@ -150,7 +195,9 @@ mod tests {
             like_id: LikeId::new(),
             user_id: alice.id.clone(),
             thought_id: thought.id.clone(),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         assert!(store.notifications.lock().unwrap().is_empty());
     }
 
@@ -166,10 +213,15 @@ mod tests {
         svc.process(&DomainEvent::FollowAccepted {
             follower_id: bob_id,
             following_id: alice.id.clone(),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         let notifs = store.notifications.lock().unwrap();
         assert_eq!(notifs.len(), 1);
-        assert!(matches!(notifs[0].notification_type, NotificationType::Follow));
+        assert!(matches!(
+            notifs[0].notification_type,
+            NotificationType::Follow
+        ));
     }
 
     #[tokio::test]
@@ -178,9 +230,13 @@ mod tests {
         let alice = alice();
         let bob_id = UserId::new();
         let original = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("original").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         );
         store.thoughts.lock().unwrap().push(original.clone());
         let svc = NotificationEventService {
@@ -191,10 +247,15 @@ mod tests {
             thought_id: ThoughtId::new(),
             user_id: bob_id,
             in_reply_to_id: Some(original.id.clone()),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         let notifs = store.notifications.lock().unwrap();
         assert_eq!(notifs.len(), 1);
-        assert!(matches!(notifs[0].notification_type, NotificationType::Reply));
+        assert!(matches!(
+            notifs[0].notification_type,
+            NotificationType::Reply
+        ));
     }
 
     #[tokio::test]
@@ -202,9 +263,13 @@ mod tests {
         let store = TestStore::default();
         let alice = alice();
         let original = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("original").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         );
         store.thoughts.lock().unwrap().push(original.clone());
         let svc = NotificationEventService {
@@ -215,7 +280,9 @@ mod tests {
             thought_id: ThoughtId::new(),
             user_id: alice.id.clone(),
             in_reply_to_id: Some(original.id.clone()),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         assert!(store.notifications.lock().unwrap().is_empty());
     }
 
@@ -224,9 +291,13 @@ mod tests {
         let store = TestStore::default();
         let alice = alice();
         let thought = Thought::new_local(
-            ThoughtId::new(), alice.id.clone(),
+            ThoughtId::new(),
+            alice.id.clone(),
             Content::new_local("hello").unwrap(),
-            None, Visibility::Public, None, false,
+            None,
+            Visibility::Public,
+            None,
+            false,
         );
         store.thoughts.lock().unwrap().push(thought.clone());
         let svc = NotificationEventService {
@@ -237,7 +308,9 @@ mod tests {
             boost_id: BoostId::new(),
             user_id: alice.id.clone(),
             thought_id: thought.id.clone(),
-        }).await.unwrap();
+        })
+        .await
+        .unwrap();
         assert!(store.notifications.lock().unwrap().is_empty());
     }
 }