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/domain/src/testing.rs

@@ -1,7 +1,3 @@
-use std::sync::{Arc, Mutex};
-use async_trait::async_trait;
-use chrono::Utc;
-use url;
 use crate::{
     errors::DomainError,
     events::DomainEvent,
@@ -17,33 +13,58 @@ use crate::{
         user::User,
     },
     ports::*,
-    value_objects::{ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username},
+    value_objects::{
+        ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username,
+    },
 };
+use async_trait::async_trait;
+use chrono::Utc;
+use std::sync::{Arc, Mutex};
+use url;
 
 #[derive(Default, Clone)]
 pub struct TestStore {
-    pub users:         Arc<Mutex<Vec<User>>>,
-    pub thoughts:      Arc<Mutex<Vec<Thought>>>,
-    pub likes:         Arc<Mutex<Vec<Like>>>,
-    pub boosts:        Arc<Mutex<Vec<Boost>>>,
-    pub follows:       Arc<Mutex<Vec<Follow>>>,
-    pub blocks:        Arc<Mutex<Vec<Block>>>,
-    pub tags:          Arc<Mutex<Vec<Tag>>>,
-    pub api_keys:      Arc<Mutex<Vec<ApiKey>>>,
-    pub top_friends:   Arc<Mutex<Vec<TopFriend>>>,
+    pub users: Arc<Mutex<Vec<User>>>,
+    pub thoughts: Arc<Mutex<Vec<Thought>>>,
+    pub likes: Arc<Mutex<Vec<Like>>>,
+    pub boosts: Arc<Mutex<Vec<Boost>>>,
+    pub follows: Arc<Mutex<Vec<Follow>>>,
+    pub blocks: Arc<Mutex<Vec<Block>>>,
+    pub tags: Arc<Mutex<Vec<Tag>>>,
+    pub api_keys: Arc<Mutex<Vec<ApiKey>>>,
+    pub top_friends: Arc<Mutex<Vec<TopFriend>>>,
     pub notifications: Arc<Mutex<Vec<Notification>>>,
-    pub events:        Arc<Mutex<Vec<DomainEvent>>>,
+    pub events: Arc<Mutex<Vec<DomainEvent>>>,
 }
 
-#[async_trait] impl UserRepository for TestStore {
+#[async_trait]
+impl UserRepository for TestStore {
     async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError> {
-        Ok(self.users.lock().unwrap().iter().find(|u| &u.id == id).cloned())
+        Ok(self
+            .users
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|u| &u.id == id)
+            .cloned())
     }
     async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
-        Ok(self.users.lock().unwrap().iter().find(|u| u.username.as_str() == username.as_str()).cloned())
+        Ok(self
+            .users
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|u| u.username.as_str() == username.as_str())
+            .cloned())
     }
     async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
-        Ok(self.users.lock().unwrap().iter().find(|u| u.email.as_str() == email.as_str()).cloned())
+        Ok(self
+            .users
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|u| u.email.as_str() == email.as_str())
+            .cloned())
     }
     async fn save(&self, user: &User) -> Result<(), DomainError> {
         let mut g = self.users.lock().unwrap();
@@ -51,8 +72,22 @@ pub struct TestStore {
         g.push(user.clone());
         Ok(())
     }
-    async fn update_profile(&self, user_id: &UserId, display_name: Option<String>, bio: Option<String>, avatar_url: Option<String>, header_url: Option<String>, custom_css: Option<String>) -> Result<(), DomainError> {
-        if let Some(u) = self.users.lock().unwrap().iter_mut().find(|u| &u.id == user_id) {
+    async fn update_profile(
+        &self,
+        user_id: &UserId,
+        display_name: Option<String>,
+        bio: Option<String>,
+        avatar_url: Option<String>,
+        header_url: Option<String>,
+        custom_css: Option<String>,
+    ) -> Result<(), DomainError> {
+        if let Some(u) = self
+            .users
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .find(|u| &u.id == user_id)
+        {
             u.display_name = display_name;
             u.bio = bio;
             u.avatar_url = avatar_url;
@@ -61,13 +96,22 @@ pub struct TestStore {
         }
         Ok(())
     }
-    async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError> { Ok(vec![]) }
+    async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError> {
+        Ok(vec![])
+    }
     async fn count(&self) -> Result<i64, DomainError> {
-        Ok(self.users.lock().unwrap().iter().filter(|u| u.local).count() as i64)
+        Ok(self
+            .users
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|u| u.local)
+            .count() as i64)
     }
 }
 
-#[async_trait] impl ThoughtRepository for TestStore {
+#[async_trait]
+impl ThoughtRepository for TestStore {
     async fn save(&self, t: &Thought) -> Result<(), DomainError> {
         let mut g = self.thoughts.lock().unwrap();
         g.retain(|x| x.id != t.id);
@@ -75,36 +119,67 @@ pub struct TestStore {
         Ok(())
     }
     async fn find_by_id(&self, id: &ThoughtId) -> Result<Option<Thought>, DomainError> {
-        Ok(self.thoughts.lock().unwrap().iter().find(|t| &t.id == id).cloned())
+        Ok(self
+            .thoughts
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|t| &t.id == id)
+            .cloned())
     }
     async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError> {
         let mut g = self.thoughts.lock().unwrap();
         let before = g.len();
         g.retain(|t| !(&t.id == id && &t.user_id == user_id));
-        if g.len() == before { return Err(DomainError::NotFound); }
+        if g.len() == before {
+            return Err(DomainError::NotFound);
+        }
         Ok(())
     }
     async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError> {
-        if let Some(t) = self.thoughts.lock().unwrap().iter_mut().find(|t| &t.id == id) {
+        if let Some(t) = self
+            .thoughts
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .find(|t| &t.id == id)
+        {
             t.content = content.clone();
             t.updated_at = Some(Utc::now());
         }
         Ok(())
     }
     async fn get_thread(&self, id: &ThoughtId) -> Result<Vec<Thought>, DomainError> {
-        Ok(self.thoughts.lock().unwrap().iter()
+        Ok(self
+            .thoughts
+            .lock()
+            .unwrap()
+            .iter()
             .filter(|t| t.in_reply_to_id.as_ref() == Some(id) || &t.id == id)
-            .cloned().collect())
+            .cloned()
+            .collect())
     }
-    async fn list_by_user(&self, _user_id: &UserId, _page: &PageParams) -> Result<Paginated<Thought>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn list_by_user(
+        &self,
+        _user_id: &UserId,
+        _page: &PageParams,
+    ) -> Result<Paginated<Thought>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
 }
 
-#[async_trait] impl LikeRepository for TestStore {
+#[async_trait]
+impl LikeRepository for TestStore {
     async fn save(&self, like: &Like) -> Result<(), DomainError> {
         let mut g = self.likes.lock().unwrap();
-        if g.iter().any(|l| l.user_id == like.user_id && l.thought_id == like.thought_id) {
+        if g.iter()
+            .any(|l| l.user_id == like.user_id && l.thought_id == like.thought_id)
+        {
             return Err(DomainError::Conflict("already liked".into()));
         }
         g.push(like.clone());
@@ -114,21 +189,42 @@ pub struct TestStore {
         let mut g = self.likes.lock().unwrap();
         let before = g.len();
         g.retain(|l| !(&l.user_id == user_id && &l.thought_id == thought_id));
-        if g.len() == before { return Err(DomainError::NotFound); }
+        if g.len() == before {
+            return Err(DomainError::NotFound);
+        }
         Ok(())
     }
-    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Like>, DomainError> {
-        Ok(self.likes.lock().unwrap().iter().find(|l| &l.user_id == user_id && &l.thought_id == thought_id).cloned())
+    async fn find(
+        &self,
+        user_id: &UserId,
+        thought_id: &ThoughtId,
+    ) -> Result<Option<Like>, DomainError> {
+        Ok(self
+            .likes
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|l| &l.user_id == user_id && &l.thought_id == thought_id)
+            .cloned())
     }
     async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
-        Ok(self.likes.lock().unwrap().iter().filter(|l| &l.thought_id == thought_id).count() as i64)
+        Ok(self
+            .likes
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|l| &l.thought_id == thought_id)
+            .count() as i64)
     }
 }
 
-#[async_trait] impl BoostRepository for TestStore {
+#[async_trait]
+impl BoostRepository for TestStore {
     async fn save(&self, boost: &Boost) -> Result<(), DomainError> {
         let mut g = self.boosts.lock().unwrap();
-        if g.iter().any(|b| b.user_id == boost.user_id && b.thought_id == boost.thought_id) {
+        if g.iter()
+            .any(|b| b.user_id == boost.user_id && b.thought_id == boost.thought_id)
+        {
             return Err(DomainError::Conflict("already boosted".into()));
         }
         g.push(boost.clone());
@@ -138,21 +234,42 @@ pub struct TestStore {
         let mut g = self.boosts.lock().unwrap();
         let before = g.len();
         g.retain(|b| !(&b.user_id == user_id && &b.thought_id == thought_id));
-        if g.len() == before { return Err(DomainError::NotFound); }
+        if g.len() == before {
+            return Err(DomainError::NotFound);
+        }
         Ok(())
     }
-    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Boost>, DomainError> {
-        Ok(self.boosts.lock().unwrap().iter().find(|b| &b.user_id == user_id && &b.thought_id == thought_id).cloned())
+    async fn find(
+        &self,
+        user_id: &UserId,
+        thought_id: &ThoughtId,
+    ) -> Result<Option<Boost>, DomainError> {
+        Ok(self
+            .boosts
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|b| &b.user_id == user_id && &b.thought_id == thought_id)
+            .cloned())
     }
     async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
-        Ok(self.boosts.lock().unwrap().iter().filter(|b| &b.thought_id == thought_id).count() as i64)
+        Ok(self
+            .boosts
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|b| &b.thought_id == thought_id)
+            .count() as i64)
     }
 }
 
-#[async_trait] impl FollowRepository for TestStore {
+#[async_trait]
+impl FollowRepository for TestStore {
     async fn save(&self, follow: &Follow) -> Result<(), DomainError> {
         let mut g = self.follows.lock().unwrap();
-        g.retain(|f| !(f.follower_id == follow.follower_id && f.following_id == follow.following_id));
+        g.retain(|f| {
+            !(f.follower_id == follow.follower_id && f.following_id == follow.following_id)
+        });
         g.push(follow.clone());
         Ok(())
     }
@@ -160,160 +277,386 @@ pub struct TestStore {
         let mut g = self.follows.lock().unwrap();
         let before = g.len();
         g.retain(|f| !(&f.follower_id == follower_id && &f.following_id == following_id));
-        if g.len() == before { return Err(DomainError::NotFound); }
+        if g.len() == before {
+            return Err(DomainError::NotFound);
+        }
         Ok(())
     }
-    async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result<Option<Follow>, DomainError> {
-        Ok(self.follows.lock().unwrap().iter().find(|f| &f.follower_id == follower_id && &f.following_id == following_id).cloned())
+    async fn find(
+        &self,
+        follower_id: &UserId,
+        following_id: &UserId,
+    ) -> Result<Option<Follow>, DomainError> {
+        Ok(self
+            .follows
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|f| &f.follower_id == follower_id && &f.following_id == following_id)
+            .cloned())
     }
-    async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError> {
-        if let Some(f) = self.follows.lock().unwrap().iter_mut().find(|f| &f.follower_id == follower_id && &f.following_id == following_id) {
+    async fn update_state(
+        &self,
+        follower_id: &UserId,
+        following_id: &UserId,
+        state: &FollowState,
+    ) -> Result<(), DomainError> {
+        if let Some(f) = self
+            .follows
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .find(|f| &f.follower_id == follower_id && &f.following_id == following_id)
+        {
             f.state = state.clone();
         }
         Ok(())
     }
-    async fn list_followers(&self, _user_id: &UserId, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn list_followers(
+        &self,
+        _user_id: &UserId,
+        _p: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
-    async fn list_following(&self, _user_id: &UserId, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn list_following(
+        &self,
+        _user_id: &UserId,
+        _p: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
-    async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result<Vec<UserId>, DomainError> {
-        Ok(self.follows.lock().unwrap().iter()
+    async fn get_accepted_following_ids(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<UserId>, DomainError> {
+        Ok(self
+            .follows
+            .lock()
+            .unwrap()
+            .iter()
             .filter(|f| &f.follower_id == user_id && f.state == FollowState::Accepted)
             .map(|f| f.following_id.clone())
             .collect())
     }
 }
 
-#[async_trait] impl BlockRepository for TestStore {
+#[async_trait]
+impl BlockRepository for TestStore {
     async fn save(&self, block: &Block) -> Result<(), DomainError> {
         self.blocks.lock().unwrap().push(block.clone());
         Ok(())
     }
     async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
-        self.blocks.lock().unwrap().retain(|b| !(&b.blocker_id == blocker_id && &b.blocked_id == blocked_id));
+        self.blocks
+            .lock()
+            .unwrap()
+            .retain(|b| !(&b.blocker_id == blocker_id && &b.blocked_id == blocked_id));
         Ok(())
     }
     async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError> {
-        Ok(self.blocks.lock().unwrap().iter().any(|b| &b.blocker_id == blocker_id && &b.blocked_id == blocked_id))
+        Ok(self
+            .blocks
+            .lock()
+            .unwrap()
+            .iter()
+            .any(|b| &b.blocker_id == blocker_id && &b.blocked_id == blocked_id))
     }
 }
 
-#[async_trait] impl TagRepository for TestStore {
+#[async_trait]
+impl TagRepository for TestStore {
     async fn find_or_create(&self, name: &str) -> Result<Tag, DomainError> {
         let mut g = self.tags.lock().unwrap();
-        if let Some(t) = g.iter().find(|t| t.name == name) { return Ok(t.clone()); }
-        let tag = Tag { id: g.len() as i32 + 1, name: name.to_string() };
+        if let Some(t) = g.iter().find(|t| t.name == name) {
+            return Ok(t.clone());
+        }
+        let tag = Tag {
+            id: g.len() as i32 + 1,
+            name: name.to_string(),
+        };
         g.push(tag.clone());
         Ok(tag)
     }
-    async fn attach_to_thought(&self, _tid: &ThoughtId, _tag_id: i32) -> Result<(), DomainError> { Ok(()) }
-    async fn detach_from_thought(&self, _tid: &ThoughtId) -> Result<(), DomainError> { Ok(()) }
-    async fn list_for_thought(&self, _tid: &ThoughtId) -> Result<Vec<Tag>, DomainError> { Ok(vec![]) }
-    async fn list_thoughts_by_tag(&self, _name: &str, _p: &PageParams) -> Result<Paginated<Thought>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn attach_to_thought(&self, _tid: &ThoughtId, _tag_id: i32) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn detach_from_thought(&self, _tid: &ThoughtId) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn list_for_thought(&self, _tid: &ThoughtId) -> Result<Vec<Tag>, DomainError> {
+        Ok(vec![])
+    }
+    async fn list_thoughts_by_tag(
+        &self,
+        _name: &str,
+        _p: &PageParams,
+    ) -> Result<Paginated<Thought>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
     async fn popular_tags(&self, _limit: usize) -> Result<Vec<(String, i64)>, DomainError> {
         Ok(vec![])
     }
 }
 
-#[async_trait] impl ApiKeyRepository for TestStore {
+#[async_trait]
+impl ApiKeyRepository for TestStore {
     async fn save(&self, key: &ApiKey) -> Result<(), DomainError> {
         self.api_keys.lock().unwrap().push(key.clone());
         Ok(())
     }
     async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
-        Ok(self.api_keys.lock().unwrap().iter().find(|k| k.key_hash == hash).cloned())
+        Ok(self
+            .api_keys
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|k| k.key_hash == hash)
+            .cloned())
     }
     async fn list_for_user(&self, uid: &UserId) -> Result<Vec<ApiKey>, DomainError> {
-        Ok(self.api_keys.lock().unwrap().iter().filter(|k| &k.user_id == uid).cloned().collect())
+        Ok(self
+            .api_keys
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|k| &k.user_id == uid)
+            .cloned()
+            .collect())
     }
     async fn delete(&self, id: &ApiKeyId, uid: &UserId) -> Result<(), DomainError> {
-        self.api_keys.lock().unwrap().retain(|k| !(&k.id == id && &k.user_id == uid));
+        self.api_keys
+            .lock()
+            .unwrap()
+            .retain(|k| !(&k.id == id && &k.user_id == uid));
         Ok(())
     }
 }
 
-#[async_trait] impl TopFriendRepository for TestStore {
-    async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError> {
+#[async_trait]
+impl TopFriendRepository for TestStore {
+    async fn set_top_friends(
+        &self,
+        user_id: &UserId,
+        friends: Vec<(UserId, i16)>,
+    ) -> Result<(), DomainError> {
         let mut g = self.top_friends.lock().unwrap();
         g.retain(|tf| &tf.user_id != user_id);
         for (fid, pos) in friends {
-            g.push(TopFriend { user_id: user_id.clone(), friend_id: fid, position: pos });
+            g.push(TopFriend {
+                user_id: user_id.clone(),
+                friend_id: fid,
+                position: pos,
+            });
         }
         Ok(())
     }
-    async fn list_for_user(&self, _uid: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> { Ok(vec![]) }
+    async fn list_for_user(&self, _uid: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> {
+        Ok(vec![])
+    }
 }
 
-#[async_trait] impl NotificationRepository for TestStore {
+#[async_trait]
+impl NotificationRepository for TestStore {
     async fn save(&self, n: &Notification) -> Result<(), DomainError> {
         self.notifications.lock().unwrap().push(n.clone());
         Ok(())
     }
-    async fn list_for_user(&self, uid: &UserId, _p: &PageParams) -> Result<Paginated<Notification>, DomainError> {
-        let items: Vec<_> = self.notifications.lock().unwrap().iter().filter(|n| &n.user_id == uid).cloned().collect();
+    async fn list_for_user(
+        &self,
+        uid: &UserId,
+        _p: &PageParams,
+    ) -> Result<Paginated<Notification>, DomainError> {
+        let items: Vec<_> = self
+            .notifications
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|n| &n.user_id == uid)
+            .cloned()
+            .collect();
         let total = items.len() as i64;
-        Ok(Paginated { items, total, page: 1, per_page: 20 })
+        Ok(Paginated {
+            items,
+            total,
+            page: 1,
+            per_page: 20,
+        })
     }
     async fn mark_read(&self, id: &NotificationId, _uid: &UserId) -> Result<(), DomainError> {
-        if let Some(n) = self.notifications.lock().unwrap().iter_mut().find(|n| &n.id == id) {
+        if let Some(n) = self
+            .notifications
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .find(|n| &n.id == id)
+        {
             n.read = true;
         }
         Ok(())
     }
     async fn mark_all_read(&self, uid: &UserId) -> Result<(), DomainError> {
-        for n in self.notifications.lock().unwrap().iter_mut().filter(|n| &n.user_id == uid) {
+        for n in self
+            .notifications
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .filter(|n| &n.user_id == uid)
+        {
             n.read = true;
         }
         Ok(())
     }
 }
 
-#[async_trait] impl RemoteActorRepository for TestStore {
-    async fn upsert(&self, _a: &RemoteActor) -> Result<(), DomainError> { Ok(()) }
-    async fn find_by_url(&self, _url: &str) -> Result<Option<RemoteActor>, DomainError> { Ok(None) }
-}
-
-#[async_trait] impl FeedRepository for TestStore {
-    async fn home_feed(&self, _ids: &[UserId], _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+#[async_trait]
+impl RemoteActorRepository for TestStore {
+    async fn upsert(&self, _a: &RemoteActor) -> Result<(), DomainError> {
+        Ok(())
     }
-    async fn public_feed(&self, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
-    }
-    async fn search(&self, _q: &str, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
-    }
-    async fn tag_feed(&self, _tag_name: &str, _page: &PageParams, _viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
-    }
-    async fn user_feed(&self, _user_id: &UserId, _page: &PageParams, _viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn find_by_url(&self, _url: &str) -> Result<Option<RemoteActor>, DomainError> {
+        Ok(None)
     }
 }
 
-#[async_trait] impl SearchPort for TestStore {
-    async fn search_thoughts(&self, _q: &str, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+#[async_trait]
+impl FeedRepository for TestStore {
+    async fn home_feed(
+        &self,
+        _ids: &[UserId],
+        _p: &PageParams,
+        _v: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
-    async fn search_users(&self, _q: &str, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
-        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    async fn public_feed(
+        &self,
+        _p: &PageParams,
+        _v: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
+    }
+    async fn search(
+        &self,
+        _q: &str,
+        _p: &PageParams,
+        _v: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
+    }
+    async fn tag_feed(
+        &self,
+        _tag_name: &str,
+        _page: &PageParams,
+        _viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
+    }
+    async fn user_feed(
+        &self,
+        _user_id: &UserId,
+        _page: &PageParams,
+        _viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
     }
 }
 
-#[async_trait] impl ActivityPubRepository for TestStore {
-    async fn outbox_entries_for_actor(&self, _uid: &UserId) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+#[async_trait]
+impl SearchPort for TestStore {
+    async fn search_thoughts(
+        &self,
+        _q: &str,
+        _p: &PageParams,
+        _v: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
+    }
+    async fn search_users(
+        &self,
+        _q: &str,
+        _p: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated {
+            items: vec![],
+            total: 0,
+            page: 1,
+            per_page: 20,
+        })
+    }
+}
+
+#[async_trait]
+impl ActivityPubRepository for TestStore {
+    async fn outbox_entries_for_actor(
+        &self,
+        _uid: &UserId,
+    ) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
         Ok(vec![])
     }
-    async fn outbox_page_for_actor(&self, _uid: &UserId, _before: Option<chrono::DateTime<chrono::Utc>>, _limit: usize) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+    async fn outbox_page_for_actor(
+        &self,
+        _uid: &UserId,
+        _before: Option<chrono::DateTime<chrono::Utc>>,
+        _limit: usize,
+    ) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
         Ok(vec![])
     }
-    async fn find_remote_actor_id(&self, actor_ap_url: &url::Url) -> Result<Option<UserId>, DomainError> {
+    async fn find_remote_actor_id(
+        &self,
+        actor_ap_url: &url::Url,
+    ) -> Result<Option<UserId>, DomainError> {
         let url = actor_ap_url.to_string();
-        Ok(self.users.lock().unwrap().iter()
+        Ok(self
+            .users
+            .lock()
+            .unwrap()
+            .iter()
             .find(|u| u.ap_id.as_deref() == Some(&url))
             .map(|u| u.id.clone()))
     }
@@ -322,31 +665,68 @@ pub struct TestStore {
             return Ok(uid);
         }
         let uid = UserId::new();
-        let handle = actor_ap_url.path().trim_start_matches('/').replace('/', "_");
+        let handle = actor_ap_url
+            .path()
+            .trim_start_matches('/')
+            .replace('/', "_");
         let user = crate::models::user::User {
             id: uid.clone(),
             username: Username::from_trusted(handle.clone()),
             email: Email::from_trusted(format!("{}@remote", uid)),
             password_hash: PasswordHash("".into()),
-            display_name: None, bio: None, avatar_url: None, header_url: None,
-            custom_css: None, local: false,
+            display_name: None,
+            bio: None,
+            avatar_url: None,
+            header_url: None,
+            custom_css: None,
+            local: false,
             ap_id: Some(actor_ap_url.to_string()),
-            inbox_url: None, public_key: None, private_key: None,
-            created_at: chrono::Utc::now(), updated_at: chrono::Utc::now(),
+            inbox_url: None,
+            public_key: None,
+            private_key: None,
+            created_at: chrono::Utc::now(),
+            updated_at: chrono::Utc::now(),
         };
         self.users.lock().unwrap().push(user);
         Ok(uid)
     }
-    async fn accept_note(&self, _ap_id: &url::Url, _author_id: &UserId, _content: &str, _published: chrono::DateTime<chrono::Utc>, _sensitive: bool, _content_warning: Option<String>) -> Result<(), DomainError> { Ok(()) }
-    async fn apply_note_update(&self, _ap_id: &url::Url, _new_content: &str) -> Result<(), DomainError> { Ok(()) }
-    async fn retract_note(&self, _ap_id: &url::Url) -> Result<(), DomainError> { Ok(()) }
-    async fn retract_actor_notes(&self, _actor_ap_url: &url::Url) -> Result<(), DomainError> { Ok(()) }
+    async fn accept_note(
+        &self,
+        _ap_id: &url::Url,
+        _author_id: &UserId,
+        _content: &str,
+        _published: chrono::DateTime<chrono::Utc>,
+        _sensitive: bool,
+        _content_warning: Option<String>,
+    ) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn apply_note_update(
+        &self,
+        _ap_id: &url::Url,
+        _new_content: &str,
+    ) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn retract_note(&self, _ap_id: &url::Url) -> Result<(), DomainError> {
+        Ok(())
+    }
+    async fn retract_actor_notes(&self, _actor_ap_url: &url::Url) -> Result<(), DomainError> {
+        Ok(())
+    }
     async fn count_local_notes(&self) -> Result<u64, DomainError> {
-        Ok(self.thoughts.lock().unwrap().iter().filter(|t| t.local).count() as u64)
+        Ok(self
+            .thoughts
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|t| t.local)
+            .count() as u64)
     }
 }
 
-#[async_trait] impl EventPublisher for TestStore {
+#[async_trait]
+impl EventPublisher for TestStore {
     async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
         self.events.lock().unwrap().push(event.clone());
         Ok(())
@@ -354,8 +734,11 @@ pub struct TestStore {
 }
 
 pub struct NoOpEventPublisher;
-#[async_trait] impl EventPublisher for NoOpEventPublisher {
-    async fn publish(&self, _e: &DomainEvent) -> Result<(), DomainError> { Ok(()) }
+#[async_trait]
+impl EventPublisher for NoOpEventPublisher {
+    async fn publish(&self, _e: &DomainEvent) -> Result<(), DomainError> {
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -366,7 +749,10 @@ mod ap_repo_tests {
     #[tokio::test]
     async fn test_store_outbox_returns_empty() {
         let store = TestStore::default();
-        let result = store.outbox_entries_for_actor(&UserId::new()).await.unwrap();
+        let result = store
+            .outbox_entries_for_actor(&UserId::new())
+            .await
+            .unwrap();
         assert!(result.is_empty());
     }
 
@@ -388,14 +774,33 @@ mod search_tests {
     #[tokio::test]
     async fn test_store_search_thoughts_returns_empty() {
         let store = TestStore::default();
-        let result = store.search_thoughts("hello", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        let result = store
+            .search_thoughts(
+                "hello",
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+                None,
+            )
+            .await
+            .unwrap();
         assert_eq!(result.total, 0);
     }
 
     #[tokio::test]
     async fn test_store_search_users_returns_empty() {
         let store = TestStore::default();
-        let result = store.search_users("alice", &PageParams { page: 1, per_page: 20 }).await.unwrap();
+        let result = store
+            .search_users(
+                "alice",
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+            )
+            .await
+            .unwrap();
         assert_eq!(result.total, 0);
     }
 }