1use 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 #[tracing::instrument(
92 name = "interprex.provider.code_hosting.repository",
93 skip_all,
94 fields(interprex.provider.name = "github")
95 )]
96 async fn repository(&self, repository: &Repository) -> Result<RepositoryFacts> {
97 let response: GithubRepository = self
98 .user()?
99 .get(format!("/repos/{repository}"), None::<&()>)
100 .await
101 .map_err(|error| read_error("read repository", repository.to_string(), error))?;
102 response.try_into().map(|(facts, _)| facts)
103 }
104
105 #[tracing::instrument(
106 name = "interprex.provider.code_hosting.settings",
107 skip_all,
108 fields(interprex.provider.name = "github")
109 )]
110 async fn settings(&self, repository: &Repository) -> Result<RepositorySettings> {
111 let response: GithubRepository = self
112 .user()?
113 .get(format!("/repos/{repository}"), None::<&()>)
114 .await
115 .map_err(|error| {
116 read_error("read repository settings", repository.to_string(), error)
117 })?;
118 response.try_into().map(|(_, settings)| settings)
119 }
120
121 #[tracing::instrument(
122 name = "interprex.provider.code_hosting.apply_settings",
123 skip_all,
124 fields(interprex.provider.name = "github")
125 )]
126 async fn apply_settings(
127 &self,
128 repository: &Repository,
129 settings: &RepositorySettings,
130 ) -> Result<RepositorySettings> {
131 let body = GithubRepositorySettings::from(settings);
132 let response: GithubRepository = self
133 .user()?
134 .patch(format!("/repos/{repository}"), Some(&body))
135 .await
136 .map_err(|error| external("apply repository settings", error))?;
137 response.try_into().map(|(_, settings)| settings)
138 }
139
140 #[tracing::instrument(
141 name = "interprex.provider.code_hosting.put_secret",
142 skip_all,
143 fields(interprex.provider.name = "github")
144 )]
145 async fn put_secret(
146 &self,
147 repository: &Repository,
148 name: &str,
149 value: SecretString,
150 ) -> Result<()> {
151 #[derive(Deserialize)]
152 struct Key {
153 key_id: String,
154 key: String,
155 }
156 let key: Key = self
157 .user()?
158 .get(
159 format!("/repos/{repository}/actions/secrets/public-key"),
160 None::<&()>,
161 )
162 .await
163 .map_err(|error| external("read repository secret public key", error))?;
164 let decoded = STANDARD
165 .decode(key.key)
166 .map_err(|error| external("decode repository secret public key", error))?;
167 let public_key = PublicKey::from_slice(&decoded)
168 .map_err(|error| external("parse repository secret public key", error))?;
169 let encrypted = public_key
170 .seal(&mut OsRng, value.expose_secret().as_bytes())
171 .map_err(|error| external("encrypt repository secret", error))?;
172 let _: serde_json::Value = self
173 .user()?
174 .put(
175 format!("/repos/{repository}/actions/secrets/{name}"),
176 Some(
177 &json!({ "encrypted_value": STANDARD.encode(encrypted), "key_id": key.key_id }),
178 ),
179 )
180 .await
181 .map_err(|error| external("write repository secret", error))?;
182 Ok(())
183 }
184}
185
186#[cfg(test)]
187mod tests {
188 use super::GithubRepository;
189
190 #[test]
191 fn repository_fixture_normalizes_only_contract_facts() {
192 let fixture = include_str!("../tests/fixtures/repository.json");
193 let response: GithubRepository = serde_json::from_str(fixture).expect("fixture");
194 let (facts, settings) = response.try_into().expect("normalizes");
195 assert_eq!(
196 facts.repository.to_string(),
197 "civitas-forge/interprex-sandbox"
198 );
199 assert!(settings.allow_squash_merge);
200 assert!(!settings.allow_merge_commit);
201 }
202}