create graphql_opt method

Author: marcoieni

src/github/api/mod.rs

@@ -92,7 +92,46 @@ impl HttpClient {
         }
     }
 
+    /// Send a request to the GitHub API and return the response.
     fn graphql<R, V>(&self, query: &str, variables: V, org: &str) -> anyhow::Result<R>
+    where
+        R: serde::de::DeserializeOwned,
+        V: serde::Serialize,
+    {
+        let res = self.send_graphql_req(query, variables, org)?;
+
+        if let Some(error) = res.errors.first() {
+            bail!("graphql error: {}", error.message);
+        }
+
+        read_graphql_data(res)
+    }
+
+    /// Send a request to the GitHub API and return the response.
+    /// If the request contains the error type `NOT_FOUND`, this method returns `Ok(None)`.
+    fn graphql_opt<R, V>(&self, query: &str, variables: V, org: &str) -> anyhow::Result<Option<R>>
+    where
+        R: serde::de::DeserializeOwned,
+        V: serde::Serialize,
+    {
+        let res = self.send_graphql_req(query, variables, org)?;
+
+        if let Some(error) = res.errors.first() {
+            if error.type_ == Some(GraphErrorType::NotFound) {
+                return Ok(None);
+            }
+            bail!("graphql error: {}", error.message);
+        }
+
+        read_graphql_data(res)
+    }
+
+    fn send_graphql_req<R, V>(
+        &self,
+        query: &str,
+        variables: V,
+        org: &str,
+    ) -> anyhow::Result<GraphResult<R>>
     where
         R: serde::de::DeserializeOwned,
         V: serde::Serialize,
@@ -109,16 +148,9 @@ impl HttpClient {
             .context("failed to send graphql request")?
             .custom_error_for_status()?;
 
-        let res: GraphResult<R> = resp.json_annotated().with_context(|| {
+        resp.json_annotated().with_context(|| {
             format!("Failed to decode response body on graphql request with query '{query}'")
-        })?;
-        if let Some(error) = res.errors.first() {
-            bail!("graphql error: {}", error.message);
-        } else if let Some(data) = res.data {
-            Ok(data)
-        } else {
-            bail!("missing graphql data");
-        }
+        })
     }
 
     fn rest_paginated<F, T>(&self, method: &Method, url: &GitHubUrl, mut f: F) -> anyhow::Result<()>
@@ -160,6 +192,17 @@ impl HttpClient {
     }
 }
 
+fn read_graphql_data<R>(res: GraphResult<R>) -> anyhow::Result<R>
+where
+    R: serde::de::DeserializeOwned,
+{
+    if let Some(data) = res.data {
+        Ok(data)
+    } else {
+        bail!("missing graphql data");
+    }
+}
+
 fn allow_not_found(resp: Response, method: Method, url: &str) -> Result<(), anyhow::Error> {
     match resp.status() {
         StatusCode::NOT_FOUND => {
@@ -181,9 +224,19 @@ struct GraphResult<T> {
 
 #[derive(Debug, serde::Deserialize)]
 struct GraphError {
+    #[serde(rename = "type")]
+    type_: Option<GraphErrorType>,
     message: String,
 }
 
+#[derive(Debug, serde::Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "UPPERCASE")]
+enum GraphErrorType {
+    NotFound,
+    #[serde(other)]
+    Other,
+}
+
 #[derive(serde::Deserialize)]
 struct GraphNodes<T> {
     nodes: Vec<Option<T>>,

src/github/api/read.rs

@@ -272,9 +272,9 @@ impl GithubRead for GitHubApiRead {
             is_archived: bool,
         }
 
-        let result: Wrapper = self
+        let result: Option<Wrapper> = self
             .client
-            .graphql(
+            .graphql_opt(
                 QUERY,
                 Params {
                     owner: org,
@@ -284,7 +284,7 @@ impl GithubRead for GitHubApiRead {
             )
             .with_context(|| format!("failed to retrieve repo `{org}/{repo}`"))?;
 
-        let repo = result.repository.map(|repo_response| Repo {
+        let repo = result.and_then(|r| r.repository).map(|repo_response| Repo {
             node_id: repo_response.id,
             name: repo.to_string(),
             description: repo_response.description.unwrap_or_default(),