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/feed.rs

@@ -1,16 +1,26 @@
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
-use sqlx::PgPool;
+use domain::models::thought::Visibility;
 use domain::{
     errors::DomainError,
-    models::{feed::{FeedEntry, PageParams, Paginated}, thought::Thought, user::User},
+    models::{
+        feed::{FeedEntry, PageParams, Paginated},
+        thought::Thought,
+        user::User,
+    },
     ports::FeedRepository,
     value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
 };
-use domain::models::thought::Visibility;
+use sqlx::PgPool;
 
-pub struct PgFeedRepository { pool: PgPool }
-impl PgFeedRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+pub struct PgFeedRepository {
+    pool: PgPool,
+}
+impl PgFeedRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
 
 #[derive(sqlx::FromRow)]
 struct FeedRow {
@@ -57,7 +67,8 @@ fn feed_select(viewer: Option<uuid::Uuid>) -> String {
         ),
         None => "false AS liked_by_viewer, false AS boosted_by_viewer".to_string(),
     };
-    format!("
+    format!(
+        "
     SELECT
         t.id AS thought_id, t.user_id AS t_user_id, t.content,
         t.in_reply_to_id, t.in_reply_to_url, t.ap_id AS t_ap_id,
@@ -72,7 +83,8 @@ fn feed_select(viewer: Option<uuid::Uuid>) -> String {
         (SELECT COUNT(*) FROM boosts b WHERE b.thought_id=t.id) AS boost_count,
         (SELECT COUNT(*) FROM thoughts r WHERE r.in_reply_to_id=t.id) AS reply_count,
         {viewer_checks}
-    FROM thoughts t JOIN users u ON u.id=t.user_id")
+    FROM thoughts t JOIN users u ON u.id=t.user_id"
+    )
 }
 
 fn row_to_entry(r: FeedRow) -> FeedEntry {
@@ -95,52 +107,105 @@ fn row_to_entry(r: FeedRow) -> FeedEntry {
         username: Username::from_trusted(r.username),
         email: Email::from_trusted(r.email),
         password_hash: PasswordHash(r.password_hash),
-        display_name: r.display_name, bio: r.bio,
-        avatar_url: r.avatar_url, header_url: r.header_url, custom_css: r.custom_css,
-        local: r.author_local, ap_id: r.u_ap_id, inbox_url: r.inbox_url,
-        public_key: r.public_key, private_key: r.private_key,
-        created_at: r.author_created_at, updated_at: r.author_updated_at,
+        display_name: r.display_name,
+        bio: r.bio,
+        avatar_url: r.avatar_url,
+        header_url: r.header_url,
+        custom_css: r.custom_css,
+        local: r.author_local,
+        ap_id: r.u_ap_id,
+        inbox_url: r.inbox_url,
+        public_key: r.public_key,
+        private_key: r.private_key,
+        created_at: r.author_created_at,
+        updated_at: r.author_updated_at,
     };
-    FeedEntry { thought, author, like_count: r.like_count, boost_count: r.boost_count, reply_count: r.reply_count, liked_by_viewer: r.liked_by_viewer, boosted_by_viewer: r.boosted_by_viewer }
+    FeedEntry {
+        thought,
+        author,
+        like_count: r.like_count,
+        boost_count: r.boost_count,
+        reply_count: r.reply_count,
+        liked_by_viewer: r.liked_by_viewer,
+        boosted_by_viewer: r.boosted_by_viewer,
+    }
 }
 
 #[async_trait]
 impl FeedRepository for PgFeedRepository {
-    async fn home_feed(&self, following_ids: &[UserId], page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn home_feed(
+        &self,
+        following_ids: &[UserId],
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
         let ids: Vec<uuid::Uuid> = following_ids.iter().map(|id| id.as_uuid()).collect();
         let viewer = viewer_id.map(|v| v.as_uuid());
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id=ANY($1) AND t.visibility='public'"
-        ).bind(&ids).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id=ANY($1) AND t.visibility='public'",
+        )
+        .bind(&ids)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
 
         let sel = feed_select(viewer);
         let sql = format!("{sel} WHERE t.user_id=ANY($1) AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3");
         let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(&ids).bind(page.limit()).bind(page.offset())
-            .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+            .bind(&ids)
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
 
-        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+        Ok(Paginated {
+            items: rows.into_iter().map(row_to_entry).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
     }
 
-    async fn public_feed(&self, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn public_feed(
+        &self,
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
         let viewer = viewer_id.map(|v| v.as_uuid());
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'"
-        ).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+            "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'",
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
 
         let sel = feed_select(viewer);
         let sql = format!("{sel} WHERE t.local=true AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $1 OFFSET $2");
         let rows = sqlx::query_as::<_, FeedRow>(&sql)
-            .bind(page.limit()).bind(page.offset())
-            .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
 
-        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+        Ok(Paginated {
+            items: rows.into_iter().map(row_to_entry).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
     }
 
-    async fn search(&self, query: &str, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn search(
+        &self,
+        query: &str,
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
         let viewer = viewer_id.map(|v| v.as_uuid());
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'"
+            "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'",
         )
         .bind(query)
         .fetch_one(&self.pool)
@@ -157,16 +222,26 @@ impl FeedRepository for PgFeedRepository {
             .await
             .map_err(|e| DomainError::Internal(e.to_string()))?;
 
-        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+        Ok(Paginated {
+            items: rows.into_iter().map(row_to_entry).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
     }
 
-    async fn tag_feed(&self, tag_name: &str, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn tag_feed(
+        &self,
+        tag_name: &str,
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
         let viewer = viewer_id.map(|v| v.as_uuid());
         let total: i64 = sqlx::query_scalar(
             "SELECT COUNT(*) FROM thoughts t
              JOIN thought_tags tt ON tt.thought_id = t.id
              JOIN tags tg ON tg.id = tt.tag_id
-             WHERE tg.name = $1 AND t.visibility = 'public'"
+             WHERE tg.name = $1 AND t.visibility = 'public'",
         )
         .bind(tag_name)
         .fetch_one(&self.pool)
@@ -197,12 +272,17 @@ impl FeedRepository for PgFeedRepository {
         })
     }
 
-    async fn user_feed(&self, user_id: &UserId, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn user_feed(
+        &self,
+        user_id: &UserId,
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
         let viewer = viewer_id.map(|v| v.as_uuid());
         let uid = user_id.as_uuid();
 
         let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND t.visibility = 'public'"
+            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND t.visibility = 'public'",
         )
         .bind(uid)
         .fetch_one(&self.pool)
@@ -231,15 +311,35 @@ impl FeedRepository for PgFeedRepository {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use domain::{models::{thought::{Thought, Visibility}, user::User}, ports::{ThoughtRepository, UserRepository}, value_objects::*};
     use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::{
+        models::{
+            thought::{Thought, Visibility},
+            user::User,
+        },
+        ports::{ThoughtRepository, UserRepository},
+        value_objects::*,
+    };
 
     async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
         let urepo = PgUserRepository::new(pool.clone());
         let trepo = PgThoughtRepository::new(pool.clone());
-        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(format!("{username}@ex.com")).unwrap(), PasswordHash("h".into()));
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(format!("{username}@ex.com")).unwrap(),
+            PasswordHash("h".into()),
+        );
         urepo.save(&u).await.unwrap();
-        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local(content).unwrap(), None, Visibility::Public, None, false);
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            u.id.clone(),
+            Content::new_local(content).unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
         trepo.save(&t).await.unwrap();
         (u, t)
     }
@@ -248,7 +348,16 @@ mod tests {
     async fn public_feed_returns_local_thoughts(pool: sqlx::PgPool) {
         let (_, _) = seed(&pool, "alice", "hello").await;
         let repo = PgFeedRepository::new(pool);
-        let result = repo.public_feed(&PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        let result = repo
+            .public_feed(
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+                None,
+            )
+            .await
+            .unwrap();
         assert_eq!(result.total, 1);
         assert_eq!(result.items[0].thought.content.as_str(), "hello");
     }
@@ -258,8 +367,21 @@ mod tests {
         let (_, _) = seed(&pool, "alice", "hello world").await;
         let (_, _) = seed(&pool, "bob", "goodbye world").await;
         let repo = PgFeedRepository::new(pool);
-        let result = repo.search("hello world", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        let result = repo
+            .search(
+                "hello world",
+                &PageParams {
+                    page: 1,
+                    per_page: 20,
+                },
+                None,
+            )
+            .await
+            .unwrap();
         assert!(result.total >= 1);
-        assert!(result.items.iter().any(|e| e.thought.content.as_str() == "hello world"));
+        assert!(result
+            .items
+            .iter()
+            .any(|e| e.thought.content.as_str() == "hello world"));
     }
 }