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
8fn 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
111const 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 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); 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([(
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}