Skip to main content

interprex_github/
issues.rs

1//! Issue and label operations owned by the issues domain.
2//!
3//! GitHub presents pull requests through its issues routes too, but this module
4//! intentionally models only issues and label taxonomy. Pull-request review
5//! facts remain in `code_reviews`, preventing a convenient vendor route from
6//! moving ownership between contracts.
7
8use async_trait::async_trait;
9use interprex::{
10    Issue, IssueNumber, IssuesProvider, Label, OpenClosed, ProviderError, Repository, Result,
11};
12use octocrab::Page;
13use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
14use serde::Deserialize;
15
16use crate::{GithubProvider, client::external};
17
18#[derive(Deserialize)]
19struct GithubIssue {
20    number: u64,
21    title: String,
22    body: Option<String>,
23    state: String,
24    #[serde(default)]
25    labels: Vec<GithubLabel>,
26    updated_at: chrono::DateTime<chrono::Utc>,
27    pull_request: Option<serde_json::Value>,
28}
29
30#[derive(Deserialize)]
31struct GithubLabel {
32    name: String,
33    color: String,
34    description: Option<String>,
35}
36
37impl From<GithubLabel> for Label {
38    fn from(value: GithubLabel) -> Self {
39        Self {
40            name: value.name,
41            color: value.color,
42            description: value.description,
43        }
44    }
45}
46
47fn normalize_issue(value: GithubIssue) -> Result<Issue> {
48    if value.pull_request.is_some() {
49        return Err(ProviderError::Unrepresentable {
50            provider: "github",
51            fact: "an issue-domain read addressed a pull request".to_owned(),
52        });
53    }
54    Ok(Issue {
55        number: IssueNumber::new(value.number).map_err(|error| ProviderError::Unrepresentable {
56            provider: "github",
57            fact: error.to_string(),
58        })?,
59        title: value.title,
60        body: value.body,
61        state: match value.state.as_str() {
62            "open" => OpenClosed::Open,
63            "closed" => OpenClosed::Closed,
64            other => {
65                return Err(ProviderError::Unrepresentable {
66                    provider: "github",
67                    fact: format!("unknown issue state {other}"),
68                });
69            }
70        },
71        labels: value.labels.into_iter().map(Into::into).collect(),
72        updated_at: value.updated_at,
73    })
74}
75
76#[async_trait]
77impl IssuesProvider for GithubProvider {
78    #[tracing::instrument(
79        name = "interprex.provider.issues.issue",
80        skip_all,
81        fields(interprex.provider.name = "github")
82    )]
83    async fn issue(&self, repository: &Repository, number: IssueNumber) -> Result<Issue> {
84        let response: GithubIssue = self
85            .user()?
86            .get(
87                format!("/repos/{repository}/issues/{}", number.get()),
88                None::<&()>,
89            )
90            .await
91            .map_err(|error| {
92                crate::client::read_error(
93                    "read issue",
94                    format!("issue {} in {repository}", number.get()),
95                    error,
96                )
97            })?;
98        normalize_issue(response)
99    }
100
101    #[tracing::instrument(
102        name = "interprex.provider.issues.labels",
103        skip_all,
104        fields(interprex.provider.name = "github")
105    )]
106    async fn labels(&self, repository: &Repository) -> Result<Vec<Label>> {
107        let page: Page<GithubLabel> = self
108            .user()?
109            .get(
110                format!("/repos/{repository}/labels"),
111                Some(&[("per_page", 100)]),
112            )
113            .await
114            .map_err(|error| external("list labels", error))?;
115        let response = self
116            .user()?
117            .all_pages(page)
118            .await
119            .map_err(|error| external("list labels", error))?;
120        Ok(response.into_iter().map(Into::into).collect())
121    }
122
123    #[tracing::instrument(
124        name = "interprex.provider.issues.upsert_label",
125        skip_all,
126        fields(interprex.provider.name = "github")
127    )]
128    async fn upsert_label(&self, repository: &Repository, label: &Label) -> Result<Label> {
129        let existing = self.labels(repository).await?;
130        let response: GithubLabel = if existing.iter().any(|existing| existing.name == label.name) {
131            self.user()?
132                .patch(
133                    format!(
134                        "/repos/{repository}/labels/{}",
135                        utf8_percent_encode(&label.name, NON_ALPHANUMERIC)
136                    ),
137                    Some(label),
138                )
139                .await
140                .map_err(|error| external("update label", error))?
141        } else {
142            self.user()?
143                .post(format!("/repos/{repository}/labels"), Some(label))
144                .await
145                .map_err(|error| external("create label", error))?
146        };
147        Ok(response.into())
148    }
149}
150
151#[cfg(test)]
152mod tests {
153    use super::{GithubIssue, normalize_issue};
154
155    #[test]
156    fn issue_fixture_normalizes_labels_and_state() {
157        let response: GithubIssue =
158            serde_json::from_str(include_str!("../tests/fixtures/issue.json")).expect("fixture");
159        let issue = normalize_issue(response).expect("normalizes");
160        assert_eq!(issue.number.get(), 11);
161        assert_eq!(issue.labels[0].name, "feature");
162    }
163
164    #[test]
165    fn unknown_issue_states_are_unrepresentable() {
166        let mut response: GithubIssue =
167            serde_json::from_str(include_str!("../tests/fixtures/issue.json")).expect("fixture");
168        response.state = "reopening".to_owned();
169        let error = normalize_issue(response).expect_err("unknown state must be unrepresentable");
170        assert!(matches!(
171            error,
172            interprex::ProviderError::Unrepresentable { fact, .. }
173                if fact.contains("unknown issue state")
174        ));
175    }
176}