refactor: wrap direct port calls behind use cases — notifications, search, popular_tags

crates/presentation/src/handlers/feed.rs

@@ -1,7 +1,8 @@
 use axum::{extract::{Path, Query, State}, Json};
 use api_types::requests::{PaginationQuery, SearchQuery};
 use api_types::responses::ThoughtResponse;
-use application::use_cases::feed::{get_home_feed, get_public_feed, get_followers, get_following, get_user_feed, get_by_tag};
+use application::use_cases::feed::{get_home_feed, get_public_feed, get_followers, get_following, get_user_feed, get_by_tag, get_popular_tags as uc_get_popular_tags};
+use application::use_cases::search::{search_thoughts, search_users};
 use domain::models::feed::PageParams;
 use crate::{errors::ApiError, extractors::{AuthUser, OptionalAuthUser}, handlers::auth::to_user_response, state::AppState};
 use application::use_cases::profile::get_user_by_username;
@@ -72,8 +73,8 @@ pub async fn search_handler(
     let query = q.q.trim().to_string();
 
     let (thoughts_result, users_result) = tokio::join!(
-        s.search.search_thoughts(&query, &page, viewer.as_ref()),
-        s.search.search_users(&query, &page),
+        search_thoughts(&*s.search, &query, PageParams { page: page.page, per_page: page.per_page }, viewer.as_ref()),
+        search_users(&*s.search, &query, PageParams { page: page.page, per_page: page.per_page }),
     );
 
     let thoughts = thoughts_result?.items.into_iter().map(|e| serde_json::json!({
@@ -139,7 +140,7 @@ pub async fn get_popular_tags(
     Query(params): Query<std::collections::HashMap<String, String>>,
 ) -> Result<Json<serde_json::Value>, ApiError> {
     let limit: usize = params.get("limit").and_then(|v| v.parse().ok()).unwrap_or(20);
-    let tags = s.tags.popular_tags(limit.min(100)).await?;
+    let tags = uc_get_popular_tags(&*s.tags, limit.min(100)).await?;
     Ok(Json(serde_json::json!({
         "tags": tags.iter().map(|(name, count)| serde_json::json!({
             "name": name,

crates/presentation/src/handlers/notifications.rs

@@ -1,21 +1,28 @@
 use axum::{extract::{Path, State}, http::StatusCode, Json};
 use uuid::Uuid;
 use domain::{models::feed::PageParams, value_objects::NotificationId};
+use application::use_cases::notifications::{
+    list_notifications as uc_list_notifications,
+    mark_notification_read as uc_mark_notification_read,
+    mark_all_notifications_read,
+};
 use crate::{errors::ApiError, extractors::AuthUser, state::AppState};
 
 #[utoipa::path(get, path = "/notifications", responses((status = 200, description = "Notification summary")), security(("bearer_auth" = [])))]
 pub async fn list_notifications(State(s): State<AppState>, AuthUser(uid): AuthUser) -> Result<Json<serde_json::Value>, ApiError> {
     let page = PageParams { page: 1, per_page: 20 };
-    let result = s.notifications.list_for_user(&uid, &page).await?;
+    let result = uc_list_notifications(&*s.notifications, &uid, page).await?;
     Ok(Json(serde_json::json!({ "total": result.total, "unread": result.items.iter().filter(|n| !n.read).count() })))
 }
+
 #[utoipa::path(post, path = "/notifications/{id}/read", params(("id" = uuid::Uuid, Path, description = "Notification ID")), responses((status = 204, description = "Marked read")), security(("bearer_auth" = [])))]
 pub async fn mark_notification_read(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
-    s.notifications.mark_read(&NotificationId::from_uuid(id), &uid).await?;
+    uc_mark_notification_read(&*s.notifications, &NotificationId::from_uuid(id), &uid).await?;
     Ok(StatusCode::NO_CONTENT)
 }
+
 #[utoipa::path(post, path = "/notifications/read-all", responses((status = 204, description = "All marked read")), security(("bearer_auth" = [])))]
 pub async fn mark_all_read(State(s): State<AppState>, AuthUser(uid): AuthUser) -> Result<StatusCode, ApiError> {
-    s.notifications.mark_all_read(&uid).await?;
+    mark_all_notifications_read(&*s.notifications, &uid).await?;
     Ok(StatusCode::NO_CONTENT)
 }

crates/presentation/src/handlers/users.rs

@@ -1,6 +1,8 @@
 use axum::{extract::{Path, Query, State}, Json};
 use api_types::{requests::UpdateProfileRequest, responses::{ErrorResponse, UserResponse}};
 use application::use_cases::profile::{get_user_by_username, update_profile};
+use application::use_cases::search::search_users;
+use application::use_cases::feed::list_users;
 use crate::{errors::ApiError, extractors::AuthUser, handlers::auth::to_user_response, state::AppState};
 
 #[utoipa::path(
@@ -54,14 +56,14 @@ pub async fn get_users(
     let page_params = PageParams { page, per_page };
 
     if let Some(q) = params.get("q").filter(|q| !q.trim().is_empty()) {
-        let result = s.search.search_users(q, &page_params).await?;
+        let result = search_users(&*s.search, q, page_params).await?;
         let users: Vec<_> = result.items.iter().map(|u| crate::handlers::auth::to_user_response(u)).collect();
         return Ok(Json(serde_json::json!({
             "items": users, "total": result.total, "page": result.page, "per_page": result.per_page
         })));
     }
 
-    let all = s.users.list_with_stats().await?;
+    let all = list_users(&*s.users).await?;
     let total = all.len() as i64;
     let start = ((page - 1) * per_page) as usize;
     let items: Vec<_> = all.into_iter()