feat: implement merge readiness plan to close gaps between v2 and v1

- Task 1: Fix feed response hydration by adding `to_thought_response` helper and updating feed handlers to return full `ThoughtResponse`.
- Task 2: Wire follower/following REST routes for user feeds.
- Task 3: Add user listing and count endpoints, including `GET /users` and `GET /users/count`.
- Task 4: Implement popular tags feature with `GET /tags/popular`.
- Task 5: Enhance configuration with HOST, CORS_ORIGINS, and optional rate limiting using tower-governor.

crates/adapters/postgres/src/follow.rs

@@ -1,15 +1,25 @@
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
-use sqlx::PgPool;
 use domain::{
     errors::DomainError,
-    models::{feed::{PageParams, Paginated}, social::{Follow, FollowState}, user::User},
+    models::{
+        feed::{PageParams, Paginated},
+        social::{Follow, FollowState},
+        user::User,
+    },
     ports::FollowRepository,
     value_objects::UserId,
 };
+use sqlx::PgPool;
 
-pub struct PgFollowRepository { pool: PgPool }
-impl PgFollowRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+pub struct PgFollowRepository {
+    pool: PgPool,
+}
+impl PgFollowRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
 
 #[async_trait]
 impl FollowRepository for PgFollowRepository {
@@ -37,13 +47,25 @@ impl FollowRepository for PgFollowRepository {
             .execute(&self.pool)
             .await
             .map_err(|e| DomainError::Internal(e.to_string()))?;
-        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
+        if r.rows_affected() == 0 {
+            return Err(DomainError::NotFound);
+        }
         Ok(())
     }
 
-    async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result<Option<Follow>, DomainError> {
+    async fn find(
+        &self,
+        follower_id: &UserId,
+        following_id: &UserId,
+    ) -> Result<Option<Follow>, DomainError> {
         #[derive(sqlx::FromRow)]
-        struct Row { follower_id: uuid::Uuid, following_id: uuid::Uuid, state: String, ap_id: Option<String>, created_at: DateTime<Utc> }
+        struct Row {
+            follower_id: uuid::Uuid,
+            following_id: uuid::Uuid,
+            state: String,
+            ap_id: Option<String>,
+            created_at: DateTime<Utc>,
+        }
         sqlx::query_as::<_, Row>(
             "SELECT follower_id,following_id,state,ap_id,created_at FROM follows WHERE follower_id=$1 AND following_id=$2"
         )
@@ -61,7 +83,12 @@ impl FollowRepository for PgFollowRepository {
         }))
     }
 
-    async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError> {
+    async fn update_state(
+        &self,
+        follower_id: &UserId,
+        following_id: &UserId,
+        state: &FollowState,
+    ) -> Result<(), DomainError> {
         sqlx::query("UPDATE follows SET state=$3 WHERE follower_id=$1 AND following_id=$2")
             .bind(follower_id.as_uuid())
             .bind(following_id.as_uuid())
@@ -72,9 +99,13 @@ impl FollowRepository for PgFollowRepository {
             .map(|_| ())
     }
 
-    async fn list_followers(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError> {
+    async fn list_followers(
+        &self,
+        user_id: &UserId,
+        page: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM follows WHERE following_id=$1 AND state='accepted'"
+            "SELECT COUNT(*) FROM follows WHERE following_id=$1 AND state='accepted'",
         )
         .bind(user_id.as_uuid())
         .fetch_one(&self.pool)
@@ -102,9 +133,13 @@ impl FollowRepository for PgFollowRepository {
         })
     }
 
-    async fn list_following(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError> {
+    async fn list_following(
+        &self,
+        user_id: &UserId,
+        page: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM follows WHERE follower_id=$1 AND state='accepted'"
+            "SELECT COUNT(*) FROM follows WHERE follower_id=$1 AND state='accepted'",
         )
         .bind(user_id.as_uuid())
         .fetch_one(&self.pool)
@@ -132,9 +167,12 @@ impl FollowRepository for PgFollowRepository {
         })
     }
 
-    async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result<Vec<UserId>, DomainError> {
+    async fn get_accepted_following_ids(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<UserId>, DomainError> {
         let ids: Vec<uuid::Uuid> = sqlx::query_scalar(
-            "SELECT following_id FROM follows WHERE follower_id=$1 AND state='accepted'"
+            "SELECT following_id FROM follows WHERE follower_id=$1 AND state='accepted'",
         )
         .bind(user_id.as_uuid())
         .fetch_all(&self.pool)
@@ -147,23 +185,35 @@ impl FollowRepository for PgFollowRepository {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use chrono::Utc;
-    use domain::{models::user::User, value_objects::*};
     use crate::user::PgUserRepository;
+    use chrono::Utc;
     use domain::ports::UserRepository;
+    use domain::{models::user::User, value_objects::*};
 
     async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
         let repo = PgUserRepository::new(pool.clone());
-        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(email).unwrap(), PasswordHash("h".into()));
-        repo.save(&u).await.unwrap(); u
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(email).unwrap(),
+            PasswordHash("h".into()),
+        );
+        repo.save(&u).await.unwrap();
+        u
     }
 
     #[sqlx::test(migrations = "./migrations")]
     async fn save_and_find_follow(pool: sqlx::PgPool) {
         let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
         let repo = PgFollowRepository::new(pool);
-        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Accepted, ap_id: None, created_at: Utc::now() };
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Accepted,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
         repo.save(&follow).await.unwrap();
         let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
         assert_eq!(found.state, FollowState::Accepted);
@@ -172,11 +222,19 @@ mod tests {
     #[sqlx::test(migrations = "./migrations")]
     async fn update_state(pool: sqlx::PgPool) {
         let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
         let repo = PgFollowRepository::new(pool);
-        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Pending, ap_id: None, created_at: Utc::now() };
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Pending,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
         repo.save(&follow).await.unwrap();
-        repo.update_state(&alice.id, &bob.id, &FollowState::Accepted).await.unwrap();
+        repo.update_state(&alice.id, &bob.id, &FollowState::Accepted)
+            .await
+            .unwrap();
         let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
         assert_eq!(found.state, FollowState::Accepted);
     }
@@ -184,9 +242,15 @@ mod tests {
     #[sqlx::test(migrations = "./migrations")]
     async fn get_accepted_following_ids(pool: sqlx::PgPool) {
         let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
         let repo = PgFollowRepository::new(pool);
-        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Accepted, ap_id: None, created_at: Utc::now() };
+        let follow = Follow {
+            follower_id: alice.id.clone(),
+            following_id: bob.id.clone(),
+            state: FollowState::Accepted,
+            ap_id: None,
+            created_at: Utc::now(),
+        };
         repo.save(&follow).await.unwrap();
         let ids = repo.get_accepted_following_ids(&alice.id).await.unwrap();
         assert_eq!(ids, vec![bob.id]);