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        .headers(reqwest::header::HeaderMap::from_iter([(
186            reqwest::header::ACCEPT,
187            reqwest::header::HeaderValue::from_static("application/vnd.github.v3.star+json"),
188        )]))
189        .send()
190        .await?;
191
192    let response = super::response::check(response)
193        .await
194        .map_err(|error| error.with_repository_context(owner, name))?;
195
196    let stargazers: Vec<StargazerWithDate> = response.json().await?;
197    Ok(stargazers)
198}
199
200fn convert_rest_repository(rest: RestRepository, lang_stats: Option<LanguageStats>) -> Repository {
201    let languages_complete = lang_stats.is_some();
202    let languages = lang_stats.map(|stats| {
203        let mut languages: Vec<_> = stats
204            .languages
205            .into_iter()
206            .map(|(name, bytes)| crate::github::models::LanguageUsage {
207                language: Language { name, color: None },
208                bytes,
209            })
210            .collect();
211        languages.sort_by(|a, b| {
212            b.bytes
213                .cmp(&a.bytes)
214                .then_with(|| a.language.name.cmp(&b.language.name))
215        });
216        languages
217    });
218    Repository {
219        node_id: rest.node_id,
220        database_id: Some(rest.id),
221        name: rest.name,
222        name_with_owner: rest.full_name,
223        description: rest.description,
224        url: rest.html_url,
225        homepage_url: rest.homepage,
226        created_at: rest.created_at,
227        updated_at: rest.updated_at,
228        pushed_at: rest.pushed_at,
229        is_private: rest.private,
230        is_fork: rest.fork,
231        is_archived: rest.archived,
232        stargazer_count: rest.stargazers_count,
233        fork_count: rest.forks_count,
234        watcher_count: rest.subscribers_count,
235        open_issue_count: None,
236        pull_request_count: None,
237        release_count: None,
238        primary_language: rest.language.map(|name| Language { name, color: None }),
239        languages,
240        languages_complete,
241        license_info: rest.license.map(|l| License {
242            name: l.name,
243            spdx_id: l.spdx_id,
244        }),
245        default_branch: Some(rest.default_branch),
246        topics: rest.topics,
247    }
248}
249
250#[cfg(test)]
251mod tests {
252    use super::*;
253    use serde_json;
254
255    #[test]
256    fn test_stargazer_deserialization() {
257        let json_data = r#"[
258            {
259                "starred_at": "2015-09-11T10:42:05Z",
260                "user": {
261                    "login": "testuser",
262                    "id": 12345,
263                    "node_id": "MDQ6VXNlcjEyMzQ1",
264                    "avatar_url": "https://avatars.githubusercontent.com/u/12345?v=4",
265                    "gravatar_id": "",
266                    "url": "https://api.github.com/users/testuser",
267                    "html_url": "https://github.com/testuser",
268                    "followers_url": "https://api.github.com/users/testuser/followers",
269                    "following_url": "https://api.github.com/users/testuser/following{/other_user}",
270                    "gists_url": "https://api.github.com/users/testuser/gists{/gist_id}",
271                    "starred_url": "https://api.github.com/users/testuser/starred{/owner}{/repo}",
272                    "subscriptions_url": "https://api.github.com/users/testuser/subscriptions",
273                    "organizations_url": "https://api.github.com/users/testuser/orgs",
274                    "repos_url": "https://api.github.com/users/testuser/repos",
275                    "events_url": "https://api.github.com/users/testuser/events{/privacy}",
276                    "received_events_url": "https://api.github.com/users/testuser/received_events",
277                    "type": "User",
278                    "site_admin": false
279                }
280            }
281        ]"#;
282
283        let stargazers: Vec<StargazerWithDate> =
284            serde_json::from_str(json_data).expect("Failed to deserialize stargazers");
285        assert_eq!(stargazers.len(), 1);
286        assert_eq!(stargazers[0].starred_at, "2015-09-11T10:42:05Z");
287        assert_eq!(stargazers[0].user.login, "testuser");
288        assert_eq!(stargazers[0].user.id, 12345);
289        assert!(!stargazers[0].user.site_admin);
290    }
291}