refactor: extract handler business logic into application use cases

11 handlers were calling repos/ports directly, bypassing the
application layer. Extracted into proper use cases:

feed: get_public_feed, get_user_feed, get_tag_feed, get_popular_tags
profile: get_user_profile (with follow check), list_users,
         count_local_users, list_local_followers, list_local_following
federation_management: set_also_known_as

Also registers 9 previously undocumented handlers in OpenAPI modules.

crates/presentation/src/handlers/federation_management.rs

@@ -7,6 +7,7 @@ use api_types::responses::{ErrorResponse, ProfileField, RemoteActorResponse};
 use application::use_cases::federation_management::{
     accept_follow_request, get_remote_friends, initiate_actor_move, list_pending_requests,
     list_remote_followers, list_remote_following, reject_follow_request, remove_remote_following,
+    set_also_known_as,
 };
 use axum::{http::StatusCode, Json};
 use domain::ports::{EventPublisher, FederationActionPort, FollowRepository, UserRepository};
@@ -208,6 +209,6 @@ pub async fn patch_also_known_as(
     AuthUser(uid): AuthUser,
     Json(body): Json<AlsoKnownAsBody>,
 ) -> Result<StatusCode, ApiError> {
-    d.users.set_also_known_as(&uid, body.also_known_as).await?;
+    set_also_known_as(&*d.users, &uid, body.also_known_as).await?;
     Ok(StatusCode::NO_CONTENT)
 }

crates/presentation/src/handlers/feed.rs

@@ -6,8 +6,13 @@ use crate::{
 };
 use api_types::requests::{PaginationQuery, SearchQuery};
 use api_types::responses::ThoughtResponse;
-use application::use_cases::feed::get_home_feed;
-use application::use_cases::profile::{get_user_by_id_or_username, get_user_by_username};
+use application::use_cases::feed::{
+    get_home_feed, get_popular_tags as uc_get_popular_tags, get_public_feed, get_tag_feed,
+    get_user_feed,
+};
+use application::use_cases::profile::{
+    get_user_by_id_or_username, get_user_by_username, list_local_followers, list_local_following,
+};
 use axum::{
     extract::{Path, Query},
     http::{header, HeaderMap},
@@ -17,8 +22,8 @@ use axum::{
 use domain::{
     models::feed::PageParams,
     ports::{
-        FederationActionPort, FeedFilter, FeedOptions, FeedQuery, FeedRepository, FeedRequest,
-        FeedSort, FollowRepository, SearchPort, TagRepository, UserRepository,
+        FederationActionPort, FeedFilter, FeedOptions, FeedRepository, FeedSort, FollowRepository,
+        SearchPort, TagRepository, UserRepository,
     },
 };
 
@@ -142,13 +147,7 @@ pub async fn public_feed(
         per_page: q.per_page(),
     };
     let opts = FeedOptions::try_from(opts_q)?;
-    let result = d
-        .feed
-        .query(&FeedRequest {
-            query: FeedQuery::public(page, viewer),
-            options: opts,
-        })
-        .await?;
+    let result = get_public_feed(&*d.feed, viewer, page, opts).await?;
     Ok(Json(serde_json::json!({
         "items": result.items.iter().map(to_thought_response).collect::<Vec<_>>(),
         "total": result.total,
@@ -232,7 +231,7 @@ pub async fn get_following_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = d.follows.list_following(&user.id, &page).await?;
+    let result = list_local_following(&*d.follows, &user.id, page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>()
@@ -275,7 +274,7 @@ pub async fn get_followers_handler(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = d.follows.list_followers(&user.id, &page).await?;
+    let result = list_local_followers(&*d.follows, &user.id, page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>()
@@ -305,13 +304,7 @@ pub async fn user_thoughts_handler(
         per_page: q.per_page(),
     };
     let opts = FeedOptions::try_from(opts_q)?;
-    let result = d
-        .feed
-        .query(&FeedRequest {
-            query: FeedQuery::user(user.id.clone(), page, viewer),
-            options: opts,
-        })
-        .await?;
+    let result = get_user_feed(&*d.feed, user.id.clone(), page, opts, viewer).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "page": result.page,
@@ -334,11 +327,9 @@ pub async fn get_popular_tags(
     let limit: usize = params
         .get("limit")
         .and_then(|v| v.parse().ok())
-        .unwrap_or(api_types::requests::DEFAULT_PER_PAGE as usize);
-    let tags = d
-        .tags
-        .popular_tags(limit.min(api_types::requests::MAX_PER_PAGE as usize))
-        .await?;
+        .unwrap_or(api_types::requests::DEFAULT_PER_PAGE as usize)
+        .min(api_types::requests::MAX_PER_PAGE as usize);
+    let tags = uc_get_popular_tags(&*d.tags, limit).await?;
     Ok(Json(serde_json::json!({
         "tags": tags.iter().map(|(name, count)| serde_json::json!({
             "name": name,
@@ -368,13 +359,7 @@ pub async fn tag_thoughts_handler(
         per_page: q.per_page(),
     };
     let opts = FeedOptions::try_from(opts_q)?;
-    let result = d
-        .feed
-        .query(&FeedRequest {
-            query: FeedQuery::tag(&tag_name, page, viewer),
-            options: opts,
-        })
-        .await?;
+    let result = get_tag_feed(&*d.feed, &tag_name, page, opts, viewer).await?;
     Ok(Json(serde_json::json!({
         "tag": tag_name,
         "total": result.total,

crates/presentation/src/handlers/users/mod.rs

@@ -9,8 +9,9 @@ use api_types::{
     responses::{ErrorResponse, ProfileField, RemoteActorResponse, UserResponse},
 };
 use application::use_cases::profile::{
-    get_user as fetch_user, get_user_by_id_or_username, update_profile,
-    upload_avatar as upload_avatar_uc, upload_banner as upload_banner_uc, UploadConfig,
+    count_local_users, get_user as fetch_user, get_user_by_id_or_username, get_user_profile,
+    list_local_following, list_users, update_profile, upload_avatar as upload_avatar_uc,
+    upload_banner as upload_banner_uc, UploadConfig,
 };
 use axum::{
     extract::{Multipart, Path, Query},
@@ -67,22 +68,18 @@ pub async fn get_user(
     OptionalAuthUser(viewer): OptionalAuthUser,
     headers: HeaderMap,
 ) -> Result<Response, ApiError> {
-    let user = get_user_by_id_or_username(&*d.users, &username).await?;
-
     let accept = headers
         .get(header::ACCEPT)
         .and_then(|v| v.to_str().ok())
         .unwrap_or("");
 
     if accept.contains("application/activity+json") {
+        let user = get_user_by_id_or_username(&*d.users, &username).await?;
         let json = d.federation.actor_json(&user.id).await?;
         Ok(([(header::CONTENT_TYPE, "application/activity+json")], json).into_response())
     } else {
-        let is_followed = if let Some(viewer_id) = viewer {
-            d.follows.find(&viewer_id, &user.id).await?.is_some()
-        } else {
-            false
-        };
+        let (user, is_followed) =
+            get_user_profile(&*d.users, &*d.follows, &username, viewer.as_ref()).await?;
         let mut resp = to_user_response(&user);
         resp.is_followed_by_viewer = is_followed;
         Ok(Json(resp).into_response())
@@ -154,7 +151,7 @@ pub async fn get_me_following(
         page: q.page(),
         per_page: q.per_page(),
     };
-    let result = d.follows.list_following(&uid, &page).await?;
+    let result = list_local_following(&*d.follows, &uid, page).await?;
     Ok(Json(serde_json::json!({
         "total": result.total,
         "items": result.items.iter().map(to_user_response).collect::<Vec<_>>(),
@@ -197,7 +194,7 @@ pub async fn get_users(
         })));
     }
 
-    let result = d.users.list_paginated(page_params).await?;
+    let result = list_users(&*d.users, page_params).await?;
     let items: Vec<_> = result
         .items
         .iter()
@@ -226,7 +223,7 @@ pub async fn get_users(
     responses((status = 200, description = "Total number of local users"))
 )]
 pub async fn get_user_count(Deps(d): Deps<UsersDeps>) -> Result<Json<serde_json::Value>, ApiError> {
-    let count = d.users.count().await?;
+    let count = count_local_users(&*d.users).await?;
     Ok(Json(serde_json::json!({ "count": count })))
 }
 

crates/presentation/src/openapi/feed.rs

@@ -6,6 +6,9 @@ use utoipa::OpenApi;
     crate::handlers::feed::public_feed,
     crate::handlers::feed::search_handler,
     crate::handlers::feed::user_thoughts_handler,
+    crate::handlers::feed::get_followers_handler,
+    crate::handlers::feed::get_following_handler,
     crate::handlers::feed::tag_thoughts_handler,
+    crate::handlers::feed::get_popular_tags,
 ))]
 pub struct FeedDoc;

crates/presentation/src/openapi/users.rs

@@ -7,9 +7,15 @@ use utoipa::OpenApi;
 #[derive(OpenApi)]
 #[openapi(
     paths(
+        crate::handlers::users::get_users,
+        crate::handlers::users::get_user_count,
+        crate::handlers::users::lookup_handler,
         crate::handlers::users::get_me,
+        crate::handlers::users::get_me_following,
         crate::handlers::users::get_user,
         crate::handlers::users::patch_profile,
+        crate::handlers::users::upload_avatar,
+        crate::handlers::users::upload_banner,
     ),
     components(schemas(UserResponse, UpdateProfileRequest, ErrorResponse))
 )]