1use async_trait::async_trait;
10use base64::{Engine as _, engine::general_purpose::STANDARD};
11use crypto_box::{PublicKey, aead::OsRng};
12use interprex::{
13 CodeHostingProvider, ProviderError, Repository, RepositoryFacts, RepositorySettings,
14 RequiredCheck, Result, Ruleset,
15};
16use octocrab::Page;
17use secrecy::{ExposeSecret, SecretString};
18use serde::{Deserialize, Serialize};
19use serde_json::json;
20
21use crate::{
22 GithubProvider,
23 client::{external, read_error},
24};
25
26#[derive(Deserialize)]
27struct GithubRepository {
28 owner: GithubOwner,
29 name: String,
30 default_branch: String,
31 private: bool,
32 archived: bool,
33 allow_squash_merge: bool,
34 allow_merge_commit: bool,
35 allow_rebase_merge: bool,
36 delete_branch_on_merge: bool,
37}
38
39#[derive(Deserialize)]
40struct GithubOwner {
41 login: String,
42}
43
44#[derive(Serialize)]
45struct GithubRepositorySettings {
46 #[serde(rename = "allow_squash_merge")]
47 squash_merge: bool,
48 #[serde(rename = "allow_merge_commit")]
49 merge_commit: bool,
50 #[serde(rename = "allow_rebase_merge")]
51 rebase_merge: bool,
52 #[serde(rename = "delete_branch_on_merge")]
53 delete_branch_after_merge: bool,
54}
55
56impl From<&RepositorySettings> for GithubRepositorySettings {
57 fn from(value: &RepositorySettings) -> Self {
58 Self {
59 squash_merge: value.allow_squash_merge,
60 merge_commit: value.allow_merge_commit,
61 rebase_merge: value.allow_rebase_merge,
62 delete_branch_after_merge: value.delete_branch_on_merge,
63 }
64 }
65}
66
67impl TryFrom<GithubRepository> for (RepositoryFacts, RepositorySettings) {
68 type Error = ProviderError;
69
70 fn try_from(value: GithubRepository) -> Result<Self> {
71 let repository = Repository::new(value.owner.login, value.name).map_err(|error| {
72 ProviderError::Unrepresentable {
73 provider: "github",
74 fact: error.to_string(),
75 }
76 })?;
77 Ok((
78 RepositoryFacts {
79 repository,
80 default_branch: value.default_branch,
81 private: value.private,
82 archived: value.archived,
83 },
84 RepositorySettings {
85 allow_squash_merge: value.allow_squash_merge,
86 allow_merge_commit: value.allow_merge_commit,
87 allow_rebase_merge: value.allow_rebase_merge,
88 delete_branch_on_merge: value.delete_branch_on_merge,
89 },
90 ))
91 }
92}
93
94#[derive(Deserialize, Serialize)]
95struct GithubRuleset {
96 id: Option<u64>,
97 name: String,
98 enforcement: String,
99 #[serde(default)]
100 conditions: Conditions,
101 #[serde(default)]
102 rules: Vec<Rule>,
103}
104
105#[derive(Default, Deserialize, Serialize)]
106struct Conditions {
107 #[serde(default)]
108 ref_name: RefName,
109}
110
111#[derive(Default, Deserialize, Serialize)]
112struct RefName {
113 #[serde(default)]
114 include: Vec<String>,
115}
116
117#[derive(Deserialize, Serialize)]
118struct Rule {
119 #[serde(rename = "type")]
120 kind: String,
121 #[serde(default)]
122 parameters: serde_json::Value,
123}
124
125fn normalize_ruleset(value: GithubRuleset) -> Ruleset {
126 let mut checks = Vec::new();
127 let mut approvals = 0;
128 for rule in value.rules {
129 if rule.kind == "required_status_checks" {
130 checks = rule.parameters["required_status_checks"]
131 .as_array()
132 .into_iter()
133 .flatten()
134 .filter_map(|check| {
135 Some(RequiredCheck {
136 context: check.get("context")?.as_str()?.to_owned(),
137 integration_id: check
138 .get("integration_id")
139 .and_then(serde_json::Value::as_u64),
140 })
141 })
142 .collect();
143 } else if rule.kind == "pull_request" {
144 approvals = rule.parameters["required_approving_review_count"]
145 .as_u64()
146 .and_then(|count| u8::try_from(count).ok())
147 .unwrap_or(0);
148 }
149 }
150 Ruleset {
151 id: value.id,
152 name: value.name,
153 active: value.enforcement == "active",
154 target_branch_patterns: value.conditions.ref_name.include,
155 required_checks: checks,
156 required_approvals: approvals,
157 }
158}
159
160fn ruleset_body(ruleset: &Ruleset) -> serde_json::Value {
161 let mut rules = vec![json!({
162 "type": "required_status_checks",
163 "parameters": {
164 "strict_required_status_checks_policy": true,
165 "do_not_enforce_on_create": false,
166 "required_status_checks": ruleset.required_checks,
167 }
168 })];
169 if ruleset.required_approvals > 0 {
170 rules.push(json!({
171 "type": "pull_request",
172 "parameters": {
173 "required_approving_review_count": ruleset.required_approvals,
174 "dismiss_stale_reviews_on_push": true,
175 "require_code_owner_review": false,
176 "require_last_push_approval": false,
177 "required_review_thread_resolution": true,
178 }
179 }));
180 }
181 json!({
182 "name": ruleset.name,
183 "target": "branch",
184 "enforcement": if ruleset.active { "active" } else { "disabled" },
185 "conditions": { "ref_name": { "include": ruleset.target_branch_patterns, "exclude": [] } },
186 "rules": rules,
187 "bypass_actors": [],
188 })
189}
190
191#[async_trait]
192impl CodeHostingProvider for GithubProvider {
193 async fn repository(&self, repository: &Repository) -> Result<RepositoryFacts> {
194 let response: GithubRepository = self
195 .user()?
196 .get(format!("/repos/{repository}"), None::<&()>)
197 .await
198 .map_err(|error| read_error("read repository", repository.to_string(), error))?;
199 response.try_into().map(|(facts, _)| facts)
200 }
201
202 async fn settings(&self, repository: &Repository) -> Result<RepositorySettings> {
203 let response: GithubRepository = self
204 .user()?
205 .get(format!("/repos/{repository}"), None::<&()>)
206 .await
207 .map_err(|error| {
208 read_error("read repository settings", repository.to_string(), error)
209 })?;
210 response.try_into().map(|(_, settings)| settings)
211 }
212
213 async fn apply_settings(
214 &self,
215 repository: &Repository,
216 settings: &RepositorySettings,
217 ) -> Result<RepositorySettings> {
218 let body = GithubRepositorySettings::from(settings);
219 let response: GithubRepository = self
220 .user()?
221 .patch(format!("/repos/{repository}"), Some(&body))
222 .await
223 .map_err(|error| external("apply repository settings", error))?;
224 response.try_into().map(|(_, settings)| settings)
225 }
226
227 async fn rulesets(&self, repository: &Repository) -> Result<Vec<Ruleset>> {
228 let page: Page<GithubRuleset> = self
229 .user()?
230 .get(
231 format!("/repos/{repository}/rulesets"),
232 Some(&[("per_page", 100)]),
233 )
234 .await
235 .map_err(|error| external("list repository rulesets", error))?;
236 let response = self
237 .user()?
238 .all_pages(page)
239 .await
240 .map_err(|error| external("list repository rulesets", error))?;
241 Ok(response.into_iter().map(normalize_ruleset).collect())
242 }
243
244 async fn upsert_ruleset(&self, repository: &Repository, ruleset: &Ruleset) -> Result<Ruleset> {
245 let body = ruleset_body(ruleset);
246 let response: GithubRuleset = if let Some(id) = ruleset.id {
247 self.user()?
248 .put(format!("/repos/{repository}/rulesets/{id}"), Some(&body))
249 .await
250 } else {
251 self.user()?
252 .post(format!("/repos/{repository}/rulesets"), Some(&body))
253 .await
254 }
255 .map_err(|error| external("upsert repository ruleset", error))?;
256 Ok(normalize_ruleset(response))
257 }
258
259 async fn put_secret(
260 &self,
261 repository: &Repository,
262 name: &str,
263 value: SecretString,
264 ) -> Result<()> {
265 #[derive(Deserialize)]
266 struct Key {
267 key_id: String,
268 key: String,
269 }
270 let key: Key = self
271 .user()?
272 .get(
273 format!("/repos/{repository}/actions/secrets/public-key"),
274 None::<&()>,
275 )
276 .await
277 .map_err(|error| external("read repository secret public key", error))?;
278 let decoded = STANDARD
279 .decode(key.key)
280 .map_err(|error| external("decode repository secret public key", error))?;
281 let public_key = PublicKey::from_slice(&decoded)
282 .map_err(|error| external("parse repository secret public key", error))?;
283 let encrypted = public_key
284 .seal(&mut OsRng, value.expose_secret().as_bytes())
285 .map_err(|error| external("encrypt repository secret", error))?;
286 let _: serde_json::Value = self
287 .user()?
288 .put(
289 format!("/repos/{repository}/actions/secrets/{name}"),
290 Some(
291 &json!({ "encrypted_value": STANDARD.encode(encrypted), "key_id": key.key_id }),
292 ),
293 )
294 .await
295 .map_err(|error| external("write repository secret", error))?;
296 Ok(())
297 }
298}
299
300#[cfg(test)]
301mod tests {
302 use super::{GithubRepository, GithubRuleset, normalize_ruleset, ruleset_body};
303
304 #[test]
305 fn repository_fixture_normalizes_only_contract_facts() {
306 let fixture = include_str!("../tests/fixtures/repository.json");
307 let response: GithubRepository = serde_json::from_str(fixture).expect("fixture");
308 let (facts, settings) = response.try_into().expect("normalizes");
309 assert_eq!(
310 facts.repository.to_string(),
311 "civitas-forge/interprex-sandbox"
312 );
313 assert!(settings.allow_squash_merge);
314 assert!(!settings.allow_merge_commit);
315 }
316
317 #[test]
318 fn ruleset_fixture_round_trips_its_enforced_policy() {
319 let fixture = include_str!("../tests/fixtures/ruleset.json");
320 let response: GithubRuleset = serde_json::from_str(fixture).expect("fixture");
321 let ruleset = normalize_ruleset(response);
322 assert_eq!(ruleset.required_checks[0].context, "quality");
323 assert_eq!(ruleset.required_approvals, 1);
324 let body = ruleset_body(&ruleset);
325 assert_eq!(body["target"], "branch");
326 }
327}