refactor(presentation/feed): call ports directly — remove shallow use case wrappers

crates/presentation/src/handlers/feed.rs

@@ -1,15 +1,12 @@
 use crate::{
+    deps_struct,
     errors::ApiError,
-    extractors::{Deps, FromAppState, OptionalAuthUser, AuthUser},
+    extractors::{AuthUser, Deps, OptionalAuthUser},
     handlers::auth::to_user_response,
-    state::AppState,
 };
 use api_types::requests::{PaginationQuery, SearchQuery};
 use api_types::responses::ThoughtResponse;
-use application::use_cases::feed::{
-    get_by_tag, get_followers, get_following, get_home_feed,
-    get_popular_tags as uc_get_popular_tags, get_public_feed, get_user_feed,
-};
+use application::use_cases::feed::get_home_feed;
 use application::use_cases::profile::{get_user_by_id_or_username, get_user_by_username};
 use axum::{
     extract::{Path, Query},
@@ -19,31 +16,17 @@ use axum::{
 };
 use domain::{
     models::feed::PageParams,
-    ports::{FederationActionPort, FeedRepository, FollowRepository, SearchPort, TagRepository, UserRepository},
+    ports::{FederationActionPort, FeedQuery, FeedRepository, FollowRepository, SearchPort, TagRepository, UserRepository},
 };
-use std::sync::Arc;
 
-pub struct FeedDeps {
-    pub feed: Arc<dyn FeedRepository>,
-    pub follows: Arc<dyn FollowRepository>,
-    pub search: Arc<dyn SearchPort>,
-    pub federation: Arc<dyn FederationActionPort>,
-    pub users: Arc<dyn UserRepository>,
-    pub tags: Arc<dyn TagRepository>,
-}
-
-impl FromAppState for FeedDeps {
-    fn from_state(s: &AppState) -> Self {
-        Self {
-            feed: s.feed.clone(),
-            follows: s.follows.clone(),
-            search: s.search.clone(),
-            federation: s.federation.clone(),
-            users: s.users.clone(),
-            tags: s.tags.clone(),
-        }
-    }
-}
+deps_struct!(FeedDeps {
+    feed: FeedRepository,
+    follows: FollowRepository,
+    search: SearchPort,
+    federation: FederationActionPort,
+    users: UserRepository,
+    tags: TagRepository,
+});
 
 pub fn to_thought_response(e: &domain::models::feed::FeedEntry) -> ThoughtResponse {
     ThoughtResponse {
@@ -103,7 +86,7 @@ pub async fn public_feed(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_public_feed(&*d.feed, viewer.as_ref(), page).await?;
+    let result = d.feed.query(&FeedQuery::public(page, viewer)).await?;
     Ok(Json(serde_json::json!({
         "items": result.items.iter().map(to_thought_response).collect::<Vec<_>>(),
         "total": result.total,
@@ -179,7 +162,7 @@ pub async fn get_following_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_following(&*d.follows, &user.id, page).await?;
+    let result = d.follows.list_following(&user.id, &page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>()
@@ -214,7 +197,7 @@ pub async fn get_followers_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_followers(&*d.follows, &user.id, page).await?;
+    let result = d.follows.list_followers(&user.id, &page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>()
@@ -241,7 +224,7 @@ pub async fn user_thoughts_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_user_feed(&*d.feed, &user.id, page, viewer.as_ref()).await?;
+    let result = d.feed.query(&FeedQuery::user(user.id.clone(), page, viewer)).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "page": result.page,
@@ -258,11 +241,7 @@ pub async fn get_popular_tags(
         .get("limit")
         .and_then(|v| v.parse().ok())
         .unwrap_or(api_types::requests::DEFAULT_PER_PAGE as usize);
-    let tags = uc_get_popular_tags(
-        &*d.tags,
-        limit.min(api_types::requests::MAX_PER_PAGE as usize),
-    )
-    .await?;
+    let tags = d.tags.popular_tags(limit.min(api_types::requests::MAX_PER_PAGE as usize)).await?;
     Ok(Json(serde_json::json!({
         "tags": tags.iter().map(|(name, count)| serde_json::json!({
             "name": name,
@@ -289,7 +268,7 @@ pub async fn tag_thoughts_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_by_tag(&*d.feed, &tag_name, page, viewer.as_ref()).await?;
+    let result = d.feed.query(&FeedQuery::tag(&tag_name, page, viewer)).await?;
     Ok(Json(serde_json::json!({
         "tag": tag_name,
         "total": result.total,

crates/presentation/src/handlers/users.rs

@@ -8,7 +8,6 @@ use api_types::{
     requests::{PaginationQuery, UpdateProfileRequest},
     responses::{ErrorResponse, ProfileField, RemoteActorResponse, UserResponse},
 };
-use application::use_cases::feed::list_users_paginated;
 use application::use_cases::profile::{
     get_user as fetch_user, get_user_by_id_or_username, update_profile,
 };
@@ -129,13 +128,12 @@ pub async fn get_me_following(
     AuthUser(uid): AuthUser,
     Query(q): Query<PaginationQuery>,
 ) -> Result<Json<serde_json::Value>, ApiError> {
-    use application::use_cases::feed::get_following;
     use domain::models::feed::PageParams;
     let page = PageParams {
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = get_following(&*d.follows, &uid, page).await?;
+    let result = d.follows.list_following(&uid, &page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>(),
@@ -169,7 +167,7 @@ pub async fn get_users(
         })));
     }
 
-    let result = list_users_paginated(&*d.users, page_params).await?;
+    let result = d.users.list_paginated(page_params).await?;
     let items: Vec<_> = result
         .items
         .iter()