Add new fields to PullRequests query

Closes #170
- Added new fields (specified in #170) to the `PullRequests` GraphQL query.
- Extended `GitHubPullRequests` to store the additional data.
- Implemented support for nested types like labels, comments, reviews,
  and commits.
- Derived `Serialize`/`Deserialize` for new types to enable database
  storage.

Author: jadenow

CHANGELOG.md

@@ -11,6 +11,8 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Tracing with a filter set by `RUST_LOG` environment variable.
 - Added support for passing the SSH passphrase through the `SSH_PASSPHRASE`
   environment variable.
+- Added new fields to the `PullRequests` GraphQL query and corresponding fields to
+  the `graphql::pull_request::PullRequest` struct.
 
 ### Changed
 

Cargo.lock

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+chrono = { version = "0.4", features = ["serde"] }
 anyhow = "1"
-async-graphql = "7"
+async-graphql = { version = "7", features = ["chrono"] }
 async-graphql-warp = "7"
 base64 = "0.22"
 bincode = "1"
-chrono = "0.4"
 clap = { version = "4", features = ["derive"] }
 config = { version = "0.15", features = ["toml"], default-features = false }
 directories = "6"

Cargo.toml

@@ -83,11 +83,7 @@ impl Database {
     ) -> Result<()> {
         for item in resp {
             let keystr: String = format!("{owner}/{name}#{}", item.number);
-            Database::insert(
-                &keystr,
-                (&item.title, &item.assignees, &item.reviewers),
-                &self.pull_request_tree,
-            )?;
+            Database::insert(&keystr, &item, &self.pull_request_tree)?;
         }
         Ok(())
     }

src/database.rs

@@ -1,10 +1,10 @@
 use std::{sync::Arc, time::Duration};
 
 use anyhow::{bail, Context, Result};
-use chrono::Utc;
+use chrono::{DateTime as ChronoDateTime, Utc};
 use graphql_client::{GraphQLQuery, QueryBody, Response as GraphQlResponse};
 use reqwest::{Client, RequestBuilder, Response};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tokio::time;
 use tracing::error;
 
@@ -13,45 +13,176 @@ use crate::{database::Database, github::{
     pull_requests::PullRequestsRepositoryPullRequestsNodesReviewRequestsNodesRequestedReviewer::User,
 }, settings::Repository as RepoInfo};
 
+pub(crate) use pull_requests::{PullRequestState, PullRequestReviewState};
+
 const GITHUB_FETCH_SIZE: i64 = 10;
 const GITHUB_URL: &str = "https://api.github.com/graphql";
 const APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
 const INIT_TIME: &str = "1992-06-05T00:00:00Z";
 
-type DateTime = String;
-
+type DateTime = ChronoDateTime<Utc>;
+#[allow(clippy::upper_case_acronyms)]
+type URI = String;
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "src/github/schema.graphql",
     query_path = "src/github/issues.graphql",
-    response_derives = "Debug"
+    response_derives = "Debug",
+    scalar = "DateTime = ChronoDateTime<Utc>"
 )]
 struct Issues;
 
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "src/github/schema.graphql",
-    query_path = "src/github/pull_requests.graphql"
+    query_path = "src/github/pull_requests.graphql",
+    response_derives = "Debug, Clone, PartialEq, Eq",
+    scalar = "DateTime = ChronoDateTime<Utc>",
+    scalar = "URI = URI"
 )]
 struct PullRequests;
 
 #[derive(Debug)]
-pub(super) struct GitHubIssue {
-    pub(super) number: i64,
-    pub(super) title: String,
-    pub(super) author: String,
-    pub(super) closed_at: Option<DateTime>,
+pub struct GitHubIssue {
+    pub number: i64,
+    pub title: String,
+    pub author: String,
+    pub closed_at: Option<ChronoDateTime<Utc>>,
 }
 
-#[derive(Debug)]
-pub(super) struct GitHubPullRequests {
-    pub(super) number: i64,
-    pub(super) title: String,
-    pub(super) assignees: Vec<String>,
-    pub(super) reviewers: Vec<String>,
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RepositoryNode {
+    pub owner: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubUserConnection {
+    pub nodes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LabelNode {
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubLabelConnection {
+    pub nodes: Vec<LabelNode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CommentNode {
+    pub body: String,
+    #[serde(rename = "createdAt")]
+    pub created_at: ChronoDateTime<Utc>,
+    #[serde(rename = "updatedAt")]
+    pub updated_at: ChronoDateTime<Utc>,
+    pub author: Option<String>,
 }
 
-pub(super) async fn fetch_periodically(
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubCommentConnection {
+    #[serde(rename = "totalCount")]
+    pub total_count: i32,
+    pub nodes: Vec<CommentNode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReviewNode {
+    pub author: Option<String>,
+    pub state: PullRequestReviewState,
+    pub body: Option<String>,
+    pub url: String,
+    #[serde(rename = "createdAt")]
+    pub created_at: ChronoDateTime<Utc>,
+    #[serde(rename = "publishedAt")]
+    pub published_at: Option<ChronoDateTime<Utc>>,
+    #[serde(rename = "submittedAt")]
+    pub submitted_at: Option<ChronoDateTime<Utc>>,
+    #[serde(rename = "isMinimized")]
+    pub is_minimized: bool,
+    pub comments: GitHubCommentConnection,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubReviewConnection {
+    #[serde(rename = "totalCount")]
+    pub total_count: i32,
+    pub nodes: Vec<ReviewNode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReviewRequestNode {
+    #[serde(rename = "requestedReviewer")]
+    pub requested_reviewer: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubReviewRequestConnection {
+    pub nodes: Vec<ReviewRequestNode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CommitPerson {
+    pub user: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CommitInner {
+    pub additions: i32,
+    pub deletions: i32,
+    pub message: String,
+    #[serde(rename = "messageBody")]
+    pub message_body: Option<String>,
+    pub author: Option<CommitPerson>,
+    #[serde(rename = "changedFilesIfAvailable")]
+    pub changed_files_if_available: Option<i32>,
+    #[serde(rename = "committedDate")]
+    pub committed_date: ChronoDateTime<Utc>,
+    pub committer: Option<CommitPerson>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitHubCommitConnection {
+    #[serde(rename = "totalCount")]
+    pub total_count: i32,
+    #[serde(rename = "nodes")]
+    pub nodes: Vec<CommitInner>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GitHubPullRequests {
+    pub id: String,
+    pub number: i32,
+    pub title: String,
+    pub body: Option<String>,
+    pub state: PullRequestState,
+    #[serde(rename = "createdAt")]
+    pub created_at: ChronoDateTime<Utc>,
+    #[serde(rename = "updatedAt")]
+    pub updated_at: ChronoDateTime<Utc>,
+    #[serde(rename = "closedAt")]
+    pub closed_at: Option<ChronoDateTime<Utc>>,
+    #[serde(rename = "mergedAt")]
+    pub merged_at: Option<ChronoDateTime<Utc>>,
+    pub author: Option<String>,
+    pub additions: i32,
+    pub deletions: i32,
+    pub url: String,
+    pub repository: RepositoryNode,
+    pub labels: GitHubLabelConnection,
+    pub comments: GitHubCommentConnection,
+    #[serde(rename = "reviewDecision")]
+    pub review_decision: Option<PullRequestReviewState>,
+    pub assignees: GitHubUserConnection,
+    #[serde(rename = "reviewRequests")]
+    pub review_requests: GitHubReviewRequestConnection,
+    pub reviews: GitHubReviewConnection,
+    pub commits: GitHubCommitConnection,
+}
+
+pub async fn fetch_periodically(
     repositories: Arc<Vec<RepoInfo>>,
     token: String,
     period: Duration,
@@ -126,14 +257,17 @@ async fn send_github_issue_query(
     let mut end_cur: Option<String> = None;
     let mut issues: Vec<GitHubIssue> = Vec::new();
     loop {
+        let since_dt = since
+            .parse::<ChronoDateTime<Utc>>()
+            .context("Failed to parse since date")?;
         let var = issues::Variables {
             owner: owner.to_string(),
             name: name.to_string(),
             first: Some(GITHUB_FETCH_SIZE),
             last: None,
             before: None,
             after: end_cur,
-            since: Some(since.to_string()),
+            since: Some(since_dt),
         };
         let resp_body: GraphQlResponse<issues::ResponseData> =
             send_query::<Issues>(token, var).await?.json().await?;
@@ -151,7 +285,7 @@ async fn send_github_issue_query(
                             number: issue.number,
                             title: issue.title.to_string(),
                             author,
-                            closed_at: issue.closed_at.clone(),
+                            closed_at: issue.closed_at,
                         });
                     }
                     if !repository.issues.page_info.has_next_page {
@@ -175,63 +309,75 @@ async fn send_github_pr_query(
 ) -> Result<Vec<Vec<GitHubPullRequests>>> {
     let mut total_prs = Vec::new();
     let mut end_cur: Option<String> = None;
-    let mut prs: Vec<GitHubPullRequests> = Vec::new();
+
     loop {
         let var = pull_requests::Variables {
             owner: owner.to_string(),
             name: name.to_string(),
             first: Some(GITHUB_FETCH_SIZE),
             last: None,
             before: None,
-            after: end_cur,
+            after: end_cur.take(),
         };
 
         let resp_body: GraphQlResponse<pull_requests::ResponseData> =
             send_query::<PullRequests>(token, var).await?.json().await?;
+
         if let Some(data) = resp_body.data {
-            if let Some(repository) = data.repository {
-                if let Some(nodes) = repository.pull_requests.nodes.as_ref() {
-                    for pr in nodes.iter().flatten() {
-                        let mut assignees: Vec<String> = Vec::new();
-                        let mut reviewers: Vec<String> = Vec::new();
-
-                        if let Some(assignees_nodes) = pr.assignees.nodes.as_ref() {
-                            for pr_assignees in assignees_nodes.iter().flatten() {
-                                assignees.push(pr_assignees.login.clone());
+            if let Some(repo) = data.repository {
+                let mut batch = Vec::new();
+
+                if let Some(nodes) = repo.pull_requests.nodes {
+                    for pr in nodes.into_iter().flatten() {
+                        let mut assignees_list = Vec::new();
+                        if let Some(ass_nodes) = pr.assignees.nodes {
+                            for node in ass_nodes.into_iter().flatten() {
+                                assignees_list.push(node.login);
                             }
                         }
-                        if let Some(reviewers_nodes) =
-                            pr.review_requests.as_ref().and_then(|r| r.nodes.as_ref())
-                        {
-                            for pr_reviewers in reviewers_nodes.iter().flatten() {
-                                if let Some(User(on_user)) =
-                                    pr_reviewers.requested_reviewer.as_ref()
-                                {
-                                    reviewers.push(on_user.login.clone());
+                        let assignees_conn = GitHubUserConnection {
+                            nodes: assignees_list,
+                        };
+
+                        let mut rr_nodes = Vec::new();
+                        if let Some(req_conn) = pr.review_requests {
+                            if let Some(req_nodes) = req_conn.nodes {
+                                for rr in req_nodes.into_iter().flatten() {
+                                    if let Some(User(user_node)) = rr.requested_reviewer {
+                                        rr_nodes.push(ReviewRequestNode {
+                                            requested_reviewer: Some(user_node.login),
+                                        });
+                                    }
                                 }
                             }
                         }
+                        let requests_conn = GitHubReviewRequestConnection { nodes: rr_nodes };
 
-                        prs.push(GitHubPullRequests {
-                            number: pr.number,
-                            title: pr.title.to_string(),
-                            assignees,
-                            reviewers,
-                        });
-                    }
-                    if !repository.pull_requests.page_info.has_next_page {
-                        total_prs.push(prs);
-                        break;
+                        let record = GitHubPullRequests {
+                            number: i32::try_from(pr.number)
+                                .context("pull request number out of i32 range")?,
+                            title: pr.title,
+                            state: pr.state.clone(),
+                            assignees: assignees_conn,
+                            review_requests: requests_conn,
+                            ..Default::default()
+                        };
+                        batch.push(record);
                     }
-                    end_cur = repository.pull_requests.page_info.end_cursor;
-                    continue;
                 }
-                end_cur = repository.pull_requests.page_info.end_cursor;
+
+                total_prs.push(batch);
+                if !repo.pull_requests.page_info.has_next_page {
+                    break;
+                }
+                end_cur = repo.pull_requests.page_info.end_cursor;
                 continue;
             }
         }
+
         bail!("Failed to parse response data");
     }
+
     Ok(total_prs)
 }