Skip to main content

github_rust/github/
rest.rs

1use crate::error::*;
2use crate::github::client::GitHubClient;
3use crate::github::models::Repository;
4use crate::github::types::*;
5use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
6use serde::Deserialize;
7
8/// URL-encode a path segment for safe use in GitHub API URLs.
9fn encode_path_segment(segment: &str) -> String {
10    utf8_percent_encode(segment, NON_ALPHANUMERIC).to_string()
11}
12
13#[derive(Deserialize)]
14struct RestRepository {
15    id: u64,
16    node_id: String,
17    name: String,
18    full_name: String,
19    description: Option<String>,
20    html_url: String,
21    homepage: Option<String>,
22    created_at: String,
23    updated_at: String,
24    pushed_at: Option<String>,
25    private: bool,
26    fork: bool,
27    archived: bool,
28    stargazers_count: u32,
29    forks_count: u32,
30    subscribers_count: Option<u32>,
31    language: Option<String>,
32    license: Option<RestLicense>,
33    default_branch: String,
34    topics: Vec<String>,
35}
36
37#[derive(Deserialize)]
38struct RestLicense {
39    name: String,
40    spdx_id: Option<String>,
41}
42
43#[derive(Deserialize)]
44struct LanguageStats {
45    #[serde(flatten)]
46    languages: std::collections::HashMap<String, u64>,
47}
48
49#[derive(Deserialize)]
50pub struct UserProfile {
51    pub login: String,
52    pub name: Option<String>,
53}
54
55pub async fn get_repository_info(
56    client: &GitHubClient,
57    owner: &str,
58    name: &str,
59) -> Result<Repository> {
60    let encoded_owner = encode_path_segment(owner);
61    let encoded_name = encode_path_segment(name);
62    let repo_url = format!(
63        "{}/repos/{}/{}",
64        client.rest_url(),
65        encoded_owner,
66        encoded_name
67    );
68
69    let response = client.get(&repo_url).send().await?;
70
71    let response = super::response::check(response)
72        .await
73        .map_err(|error| error.with_repository_context(owner, name))?;
74
75    let rest_repo: RestRepository = response.json().await?;
76
77    let languages_url = format!(
78        "{}/repos/{}/{}/languages",
79        client.rest_url(),
80        encoded_owner,
81        encoded_name
82    );
83    let lang_response = client.get(&languages_url).send().await?;
84    let language_stats: Option<LanguageStats> =
85        if lang_response.status() != reqwest::StatusCode::NOT_FOUND {
86            Some(super::response::check(lang_response).await?.json().await?)
87        } else {
88            tracing::debug!(status = %lang_response.status(), "Language breakdown unavailable");
89            None
90        };
91
92    Ok(convert_rest_repository(rest_repo, language_stats))
93}
94
95pub async fn get_user_profile(client: &GitHubClient) -> Result<UserProfile> {
96    let user_url = format!("{}/user", client.rest_url());
97
98    let response = client.get(&user_url).send().await?;
99
100    let response = super::response::check(response).await?;
101
102    let user_profile: UserProfile = response.json().await?;
103    Ok(user_profile)
104}
105
106#[derive(Deserialize)]
107struct StarredRepository {
108    full_name: String,
109}
110
111/// Maximum number of pages to fetch for starred repositories.
112/// This limits total results to 10,000 repositories (100 pages * 100 per page).
113const MAX_STARRED_PAGES: u32 = 100;
114
115pub async fn get_user_starred_repositories(client: &GitHubClient) -> Result<Vec<String>> {
116    let mut all_starred = Vec::new();
117    let mut page = 1;
118    let per_page = 100;
119
120    loop {
121        // Safety limit to prevent infinite loops or excessive API calls
122        if page > MAX_STARRED_PAGES {
123            return Err(GitHubError::PaginationError(
124                "Starred repositories exceed the 100-page safety limit".into(),
125            ));
126        }
127        let starred_url = format!(
128            "{}/user/starred?per_page={}&page={}",
129            client.rest_url(),
130            per_page,
131            page
132        );
133
134        let response = client.get(&starred_url).send().await?;
135
136        let response = super::response::check(response).await?;
137
138        let starred_repos: Vec<StarredRepository> = response.json().await?;
139
140        if starred_repos.is_empty() {
141            break;
142        }
143
144        let repo_count = starred_repos.len();
145        all_starred.extend(starred_repos.into_iter().map(|repo| repo.full_name));
146
147        if repo_count < per_page {
148            break;
149        }
150
151        page += 1;
152    }
153
154    Ok(all_starred)
155}
156
157pub async fn get_repository_stargazers(
158    client: &GitHubClient,
159    owner: &str,
160    name: &str,
161    per_page: Option<u32>,
162    page: Option<u32>,
163) -> Result<Vec<StargazerWithDate>> {
164    let per_page = per_page.unwrap_or(30).min(100); // GitHub max is 100
165    let page = page.unwrap_or(1);
166    if per_page == 0 || page == 0 {
167        return Err(GitHubError::InvalidInput(
168            "page and per_page must be greater than zero".into(),
169        ));
170    }
171
172    let encoded_owner = encode_path_segment(owner);
173    let encoded_name = encode_path_segment(name);
174    let stargazers_url = format!(
175        "{}/repos/{}/{}/stargazers?per_page={}&page={}",
176        client.rest_url(),
177        encoded_owner,
178        encoded_name,
179        per_page,
180        page
181    );
182
183    let response = client
184        .get(&stargazers_url)
185        // Replace the default Accept value; RequestBuilder::header would append it.
186        .headers(reqwest::header::HeaderMap::from_iter([(
187            reqwest::header::ACCEPT,
188            reqwest::header::HeaderValue::from_static("application/vnd.github.v3.star+json"),
189        )]))
190        .send()
191        .await?;
192
193    let response = super::response::check(response)
194        .await
195        .map_err(|error| error.with_repository_context(owner, name))?;
196
197    let stargazers: Vec<StargazerWithDate> = response.json().await?;
198    Ok(stargazers)
199}
200
201fn convert_rest_repository(rest: RestRepository, lang_stats: Option<LanguageStats>) -> Repository {
202    let languages_complete = lang_stats.is_some();
203    let languages = lang_stats.map(|stats| {
204        let mut languages: Vec<_> = stats
205            .languages
206            .into_iter()
207            .map(|(name, bytes)| crate::github::models::LanguageUsage {
208                language: Language { name, color: None },
209                bytes,
210            })
211            .collect();
212        languages.sort_by(|a, b| {
213            b.bytes
214                .cmp(&a.bytes)
215                .then_with(|| a.language.name.cmp(&b.language.name))
216        });
217        languages
218    });
219    Repository {
220        node_id: rest.node_id,
221        database_id: Some(rest.id),
222        name: rest.name,
223        name_with_owner: rest.full_name,
224        description: rest.description,
225        url: rest.html_url,
226        homepage_url: rest.homepage,
227        created_at: rest.created_at,
228        updated_at: rest.updated_at,
229        pushed_at: rest.pushed_at,
230        is_private: rest.private,
231        is_fork: rest.fork,
232        is_archived: rest.archived,
233        stargazer_count: rest.stargazers_count,
234        fork_count: rest.forks_count,
235        watcher_count: rest.subscribers_count,
236        open_issue_count: None,
237        pull_request_count: None,
238        release_count: None,
239        primary_language: rest.language.map(|name| Language { name, color: None }),
240        languages,
241        languages_complete,
242        license_info: rest.license.map(|l| License {
243            name: l.name,
244            spdx_id: l.spdx_id,
245        }),
246        default_branch: Some(rest.default_branch),
247        topics: rest.topics,
248    }
249}