interprex_github/
code_hosting.rs1use async_trait::async_trait;
7use base64::{Engine as _, engine::general_purpose::STANDARD};
8use crypto_box::{PublicKey, aead::OsRng};
9use interprex::{
10 CodeHostingProvider, ProviderError, Repository, RepositoryFacts, RepositorySettings, Result,
11};
12use secrecy::{ExposeSecret, SecretString};
13use serde::{Deserialize, Serialize};
14use serde_json::json;
15
16use crate::{
17 GithubProvider,
18 client::{external, read_error},
19};
20
21#[derive(Deserialize)]
22struct GithubRepository {
23 owner: GithubOwner,
24 name: String,
25 default_branch: String,
26 private: bool,
27 archived: bool,
28 allow_squash_merge: bool,
29 allow_merge_commit: bool,
30 allow_rebase_merge: bool,
31 delete_branch_on_merge: bool,
32}
33
34#[derive(Deserialize)]
35struct GithubOwner {
36 login: String,
37}
38
39#[derive(Serialize)]
40struct GithubRepositorySettings {
41 #[serde(rename = "allow_squash_merge")]
42 squash_merge: bool,
43 #[serde(rename = "allow_merge_commit")]
44 merge_commit: bool,
45 #[serde(rename = "allow_rebase_merge")]
46 rebase_merge: bool,
47 #[serde(rename = "delete_branch_on_merge")]
48 delete_branch_after_merge: bool,
49}
50
51impl From<&RepositorySettings> for GithubRepositorySettings {
52 fn from(value: &RepositorySettings) -> Self {
53 Self {
54 squash_merge: value.allow_squash_merge,
55 merge_commit: value.allow_merge_commit,
56 rebase_merge: value.allow_rebase_merge,
57 delete_branch_after_merge: value.delete_branch_on_merge,
58 }
59 }
60}
61
62impl TryFrom<GithubRepository> for (RepositoryFacts, RepositorySettings) {
63 type Error = ProviderError;
64
65 fn try_from(value: GithubRepository) -> Result<Self> {
66 let repository = Repository::new(value.owner.login, value.name).map_err(|error| {
67 ProviderError::Unrepresentable {
68 provider: "github",
69 fact: error.to_string(),
70 }
71 })?;
72 Ok((
73 RepositoryFacts {
74 repository,
75 default_branch: value.default_branch,
76 private: value.private,
77 archived: value.archived,
78 },
79 RepositorySettings {
80 allow_squash_merge: value.allow_squash_merge,
81 allow_merge_commit: value.allow_merge_commit,
82 allow_rebase_merge: value.allow_rebase_merge,
83 delete_branch_on_merge: value.delete_branch_on_merge,
84 },
85 ))
86 }
87}
88
89#[async_trait]
90impl CodeHostingProvider for GithubProvider {
91 async fn repository(&self, repository: &Repository) -> Result<RepositoryFacts> {
92 let response: GithubRepository = self
93 .user()?
94 .get(format!("/repos/{repository}"), None::<&()>)
95 .await
96 .map_err(|error| read_error("read repository", repository.to_string(), error))?;
97 response.try_into().map(|(facts, _)| facts)
98 }
99
100 async fn settings(&self, repository: &Repository) -> Result<RepositorySettings> {
101 let response: GithubRepository = self
102 .user()?
103 .get(format!("/repos/{repository}"), None::<&()>)
104 .await
105 .map_err(|error| {
106 read_error("read repository settings", repository.to_string(), error)
107 })?;
108 response.try_into().map(|(_, settings)| settings)
109 }
110
111 async fn apply_settings(
112 &self,
113 repository: &Repository,
114 settings: &RepositorySettings,
115 ) -> Result<RepositorySettings> {
116 let body = GithubRepositorySettings::from(settings);
117 let response: GithubRepository = self
118 .user()?
119 .patch(format!("/repos/{repository}"), Some(&body))
120 .await
121 .map_err(|error| external("apply repository settings", error))?;
122 response.try_into().map(|(_, settings)| settings)
123 }
124
125 async fn put_secret(
126 &self,
127 repository: &Repository,
128 name: &str,
129 value: SecretString,
130 ) -> Result<()> {
131 #[derive(Deserialize)]
132 struct Key {
133 key_id: String,
134 key: String,
135 }
136 let key: Key = self
137 .user()?
138 .get(
139 format!("/repos/{repository}/actions/secrets/public-key"),
140 None::<&()>,
141 )
142 .await
143 .map_err(|error| external("read repository secret public key", error))?;
144 let decoded = STANDARD
145 .decode(key.key)
146 .map_err(|error| external("decode repository secret public key", error))?;
147 let public_key = PublicKey::from_slice(&decoded)
148 .map_err(|error| external("parse repository secret public key", error))?;
149 let encrypted = public_key
150 .seal(&mut OsRng, value.expose_secret().as_bytes())
151 .map_err(|error| external("encrypt repository secret", error))?;
152 let _: serde_json::Value = self
153 .user()?
154 .put(
155 format!("/repos/{repository}/actions/secrets/{name}"),
156 Some(
157 &json!({ "encrypted_value": STANDARD.encode(encrypted), "key_id": key.key_id }),
158 ),
159 )
160 .await
161 .map_err(|error| external("write repository secret", error))?;
162 Ok(())
163 }
164}
165
166#[cfg(test)]
167mod tests {
168 use super::GithubRepository;
169
170 #[test]
171 fn repository_fixture_normalizes_only_contract_facts() {
172 let fixture = include_str!("../tests/fixtures/repository.json");
173 let response: GithubRepository = serde_json::from_str(fixture).expect("fixture");
174 let (facts, settings) = response.try_into().expect("normalizes");
175 assert_eq!(
176 facts.repository.to_string(),
177 "civitas-forge/interprex-sandbox"
178 );
179 assert!(settings.allow_squash_merge);
180 assert!(!settings.allow_merge_commit);
181 }
182}