refactor: extract OSS Insight API client to infrastructure/http

unhappychoice · claude · unhappychoice · commit d35d6b58af0d · 2025-09-27T17:54:05.000+09:00
- Add OSS Insight API client to infrastructure/http module - Update trending.rs to use new API client - Update trending_unified_view.rs to use new API structure 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/src/infrastructure/http/mod.rs b/src/infrastructure/http/mod.rs
@@ -0,0 +1,3 @@
+pub mod oss_insight_client;
+
+pub use oss_insight_client::OssInsightClient;
diff --git a/src/infrastructure/http/oss_insight_client.rs b/src/infrastructure/http/oss_insight_client.rs
@@ -0,0 +1,124 @@
+use reqwest::Client;
+use serde::Deserialize;
+use std::time::Duration;
+
+use crate::domain::error::{GitTypeError, Result};
+use crate::infrastructure::cache::TrendingRepository;
+
+#[derive(Debug, Clone)]
+pub struct OssInsightClient {
+    client: Client,
+}
+
+impl OssInsightClient {
+    pub fn new() -> Self {
+        Self {
+            client: Client::new(),
+        }
+    }
+
+    pub async fn fetch_trending_repositories(
+        &self,
+        language: Option<&str>,
+        period: &str,
+    ) -> Result<Vec<TrendingRepository>> {
+        let api_period = match period {
+            "daily" => "past_24_hours",
+            "weekly" => "past_week",
+            "monthly" => "past_month",
+            _ => "past_24_hours",
+        };
+
+        let mut url = format!(
+            "https://api.ossinsight.io/v1/trends/repos/?period={}",
+            api_period
+        );
+
+        if let Some(lang) = language {
+            let api_lang = self.map_language_name(lang);
+            url = format!("{}&language={}", url, urlencoding::encode(&api_lang));
+        }
+
+        let response = self
+            .client
+            .get(&url)
+            .header("User-Agent", "gittype")
+            .header("Accept", "application/json")
+            .timeout(Duration::from_secs(10))
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(GitTypeError::ApiError(format!(
+                "OSS Insight API request failed: {}",
+                response.status()
+            )));
+        }
+
+        let api_response: ApiResponse = response.json().await?;
+        let repositories = self.convert_api_response(api_response);
+
+        Ok(repositories)
+    }
+
+    fn map_language_name(&self, lang: &str) -> String {
+        match lang.to_lowercase().as_str() {
+            "javascript" => "JavaScript".to_string(),
+            "typescript" => "TypeScript".to_string(),
+            "c++" => "C++".to_string(),
+            "c#" => "C#".to_string(),
+            "php" => "PHP".to_string(),
+            _ => {
+                let mut chars = lang.chars();
+                match chars.next() {
+                    None => lang.to_string(),
+                    Some(first) => {
+                        first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase()
+                    }
+                }
+            }
+        }
+    }
+
+    fn convert_api_response(&self, api_response: ApiResponse) -> Vec<TrendingRepository> {
+        api_response
+            .data
+            .rows
+            .into_iter()
+            .map(|row| TrendingRepository {
+                repo_name: row.repo_name,
+                primary_language: row.primary_language,
+                description: row.description,
+                stars: row.stars.unwrap_or_else(|| "0".to_string()),
+                forks: row.forks.unwrap_or_else(|| "0".to_string()),
+                total_score: row.total_score.unwrap_or_else(|| "0".to_string()),
+            })
+            .collect()
+    }
+}
+
+impl Default for OssInsightClient {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Deserialize)]
+struct ApiResponse {
+    data: ApiData,
+}
+
+#[derive(Deserialize)]
+struct ApiData {
+    rows: Vec<RowData>,
+}
+
+#[derive(Deserialize)]
+struct RowData {
+    repo_name: String,
+    primary_language: Option<String>,
+    description: Option<String>,
+    stars: Option<String>,
+    forks: Option<String>,
+    total_score: Option<String>,
+}
diff --git a/src/infrastructure/mod.rs b/src/infrastructure/mod.rs
@@ -1,6 +1,8 @@
 pub mod cache;
 pub mod config;
 pub mod external;
+pub mod git;
+pub mod http;
 pub mod logging;
 pub mod repository_manager;
 pub mod storage;
diff --git a/src/presentation/cli/commands/trending.rs b/src/presentation/cli/commands/trending.rs
@@ -1,10 +1,9 @@
 use crate::infrastructure::cache::{TrendingRepository, TRENDING_CACHE};
+use crate::infrastructure::http::OssInsightClient;
 use crate::presentation::cli::commands::run_game_session;
 use crate::presentation::cli::views::{trending_repository_selection_view, trending_unified_view};
 use crate::presentation::cli::Cli;
 use crate::{GitTypeError, Result};
-use reqwest::Client;
-use std::time::Duration;
 
 const SUPPORTED_LANGUAGES: &[(&str, &str)] = &[
     ("C", "C"),
@@ -52,9 +51,8 @@ pub async fn run_trending(
     }
     if let Some(name) = repo_name {
         // Direct repository selection by name
-        let client = Client::new();
         let repos =
-            fetch_trending_repositories_cached(&client, language.as_deref(), &period).await?;
+            fetch_trending_repositories_cached(&(), language.as_deref(), &period).await?;
 
         if let Some(repo) = select_repository_by_name(&repos, &name) {
             let repo_url = format!("https://github.com/{}", repo.repo_name);
@@ -72,9 +70,8 @@ pub async fn run_trending(
         }
     } else if language.is_some() {
         // Language provided - show repositories directly
-        let client = Client::new();
         let repos =
-            fetch_trending_repositories_cached(&client, language.as_deref(), &period).await?;
+            fetch_trending_repositories_cached(&(), language.as_deref(), &period).await?;
 
         if repos.is_empty() {
             return Ok(());
@@ -116,132 +113,34 @@ pub async fn run_trending(
     Ok(())
 }
 
-// Make this function public so it can be used from the UI
 pub async fn fetch_trending_repositories_cached(
-    client: &Client,
+    _client: &(),
     language: Option<&str>,
     period: &str,
 ) -> Result<Vec<TrendingRepository>> {
-    // Create cache key from parameters
     let cache_key = format!("{}:{}", language.unwrap_or("all"), period);
 
-    // Check cache first
     if let Some(cached_repos) = TRENDING_CACHE.get(&cache_key) {
         log::debug!("Using cached trending repositories for key: {}", cache_key);
         return Ok(cached_repos);
     }
 
-    // Clean up expired cache entries before making API call
     TRENDING_CACHE.cleanup_expired();
 
-    // Rate limiting: wait a bit between API calls to be respectful
-    let rate_limit_ms = 100; // 100ms
-    tokio::time::sleep(Duration::from_millis(rate_limit_ms)).await;
+    let rate_limit_ms = 100;
+    tokio::time::sleep(std::time::Duration::from_millis(rate_limit_ms)).await;
 
-    // Fetch from API
-    let repos = fetch_trending_repositories(client, language, period).await?;
+    let api_client = OssInsightClient::new();
+    let repos = api_client
+        .fetch_trending_repositories(language, period)
+        .await?;
 
-    // Cache the result
     TRENDING_CACHE.set(&cache_key, repos.clone());
     log::debug!("Cached trending repositories for key: {}", cache_key);
 
     Ok(repos)
 }
 
-async fn fetch_trending_repositories(
-    client: &Client,
-    language: Option<&str>,
-    period: &str,
-) -> Result<Vec<TrendingRepository>> {
-    let api_period = match period {
-        "daily" => "past_24_hours",
-        "weekly" => "past_week",
-        "monthly" => "past_month",
-        _ => "past_24_hours",
-    };
-
-    let mut url = format!(
-        "https://api.ossinsight.io/v1/trends/repos/?period={}",
-        api_period
-    );
-
-    if let Some(lang) = language {
-        // Map to correct language name format expected by API
-        let api_lang = match lang.to_lowercase().as_str() {
-            "javascript" => "JavaScript".to_string(),
-            "typescript" => "TypeScript".to_string(),
-            "c++" => "C++".to_string(),
-            "c#" => "C#".to_string(),
-            "php" => "PHP".to_string(),
-            _ => {
-                // Capitalize first letter for other languages
-                let mut chars = lang.chars();
-                match chars.next() {
-                    None => lang.to_string(),
-                    Some(first) => {
-                        first.to_uppercase().collect::<String>() + &chars.as_str().to_lowercase()
-                    }
-                }
-            }
-        };
-        url = format!("{}&language={}", url, urlencoding::encode(&api_lang));
-    }
-
-    let response = client
-        .get(&url)
-        .header("User-Agent", "gittype")
-        .header("Accept", "application/json")
-        .timeout(Duration::from_secs(10))
-        .send()
-        .await?;
-
-    if !response.status().is_success() {
-        return Err(GitTypeError::ApiError(format!(
-            "OSS Insight API request failed: {}",
-            response.status()
-        )));
-    }
-
-    #[derive(serde::Deserialize)]
-    struct ApiResponse {
-        data: ApiData,
-    }
-
-    #[derive(serde::Deserialize)]
-    struct ApiData {
-        rows: Vec<RowData>,
-    }
-
-    #[derive(serde::Deserialize)]
-    struct RowData {
-        repo_name: String,
-        primary_language: Option<String>,
-        description: Option<String>,
-        stars: Option<String>,
-        forks: Option<String>,
-        total_score: Option<String>,
-    }
-
-    let api_response: ApiResponse = response.json().await?;
-
-    // Convert API response to TrendingRepository objects
-    let repositories: Vec<TrendingRepository> = api_response
-        .data
-        .rows
-        .into_iter()
-        .map(|row| TrendingRepository {
-            repo_name: row.repo_name,
-            primary_language: row.primary_language,
-            description: row.description,
-            stars: row.stars.unwrap_or_else(|| "0".to_string()),
-            forks: row.forks.unwrap_or_else(|| "0".to_string()),
-            total_score: row.total_score.unwrap_or_else(|| "0".to_string()),
-        })
-        .collect();
-
-    Ok(repositories)
-}
-
 fn select_repository_by_name<'a>(
     repos: &'a [TrendingRepository],
     name: &str,
diff --git a/src/presentation/cli/views/trending_unified_view.rs b/src/presentation/cli/views/trending_unified_view.rs
@@ -380,11 +380,10 @@ pub async fn render_trending_selection_ui() -> Result<Option<String>> {
                                 })?;
 
                                 // Now fetch repositories in background
-                                let client = reqwest::Client::new();
                                 let effective_period = "daily";
 
                                 repositories = fetch_trending_repositories_cached(
-                                    &client,
+                                    &(),
                                     Some(lang_code),
                                     effective_period,
                                 )

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+pub mod oss_insight_client;`
	`2`	`+`
	`3`	`+pub use oss_insight_client::OssInsightClient;`