Skip to main content

interprex_github/
code_hosting.rs

1//! Repository settings, rules, and secret transport owned by code hosting.
2//!
3//! Settings use GitHub's typed repository response. Rulesets use the raw REST
4//! route because Octocrab does not type their policy structure; normalization
5//! keeps only provider-neutral enforcement, branch, check, and approval facts.
6//! Secret values are sealed with the repository public key before the write and
7//! are never retained by the provider.
8
9use 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}