Move GraphQL to a separate package.

Author: ehuss

Cargo.lock

@@ -39,6 +39,7 @@ route-recognizer = "0.3.0"
 cynic = { version = "0.14" }
 itertools = "0.10.2"
 tower = { version = "0.4.13", features = ["util", "limit", "buffer", "load-shed"] }
+github-graphql = { path = "github-graphql" }
 
 [dependencies.serde]
 version = "1"

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "github-graphql"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+chrono = { version = "0.4", features = ["serde"] }
+cynic = { version = "0.14" }

github-graphql/Cargo.toml

@@ -0,0 +1,160 @@
+//! Definitions for GitHub GraphQL.
+//!
+//! See <https://docs.github.com/en/graphql> for more GitHub's GraphQL API.
+
+// This schema can be downloaded from https://docs.github.com/en/graphql/overview/public-schema
+#[cynic::schema_for_derives(file = "src/github.graphql", module = "schema")]
+pub mod queries {
+    use super::schema;
+
+    pub type DateTime = chrono::DateTime<chrono::Utc>;
+
+    cynic::impl_scalar!(DateTime, schema::DateTime);
+
+    #[derive(cynic::FragmentArguments, Debug)]
+    pub struct LeastRecentlyReviewedPullRequestsArguments {
+        pub repository_owner: String,
+        pub repository_name: String,
+        pub after: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(
+        graphql_type = "Query",
+        argument_struct = "LeastRecentlyReviewedPullRequestsArguments"
+    )]
+    pub struct LeastRecentlyReviewedPullRequests {
+        #[arguments(owner = &args.repository_owner, name = &args.repository_name)]
+        pub repository: Option<Repository>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(argument_struct = "LeastRecentlyReviewedPullRequestsArguments")]
+    pub struct Repository {
+        #[arguments(states = Some(vec![PullRequestState::Open]), first = 100, after = &args.after, labels = Some(vec!["S-waiting-on-review".to_string()]), order_by = IssueOrder { direction: OrderDirection::Asc, field: IssueOrderField::UpdatedAt })]
+        pub pull_requests: PullRequestConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PullRequestConnection {
+        pub total_count: i32,
+        pub page_info: PageInfo,
+        pub nodes: Option<Vec<Option<PullRequest>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PullRequest {
+        pub number: i32,
+        pub created_at: DateTime,
+        pub url: Uri,
+        pub title: String,
+        #[arguments(first = 100)]
+        pub labels: Option<LabelConnection>,
+        pub is_draft: bool,
+        #[arguments(first = 100)]
+        pub assignees: UserConnection,
+        #[arguments(first = 100, order_by = IssueCommentOrder { direction: OrderDirection::Desc, field: IssueCommentOrderField::UpdatedAt })]
+        pub comments: IssueCommentConnection,
+        #[arguments(last = 20)]
+        pub latest_reviews: Option<PullRequestReviewConnection>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PullRequestReviewConnection {
+        pub total_count: i32,
+        pub nodes: Option<Vec<Option<PullRequestReview>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PullRequestReview {
+        pub author: Option<Actor>,
+        pub created_at: DateTime,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct UserConnection {
+        pub nodes: Option<Vec<Option<User>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct User {
+        pub login: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PageInfo {
+        pub has_next_page: bool,
+        pub end_cursor: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct LabelConnection {
+        pub nodes: Option<Vec<Option<Label>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct Label {
+        pub name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct IssueCommentConnection {
+        pub total_count: i32,
+        pub nodes: Option<Vec<Option<IssueComment>>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct IssueComment {
+        pub author: Option<Actor>,
+        pub created_at: DateTime,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum IssueCommentOrderField {
+        UpdatedAt,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum IssueOrderField {
+        Comments,
+        CreatedAt,
+        UpdatedAt,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum OrderDirection {
+        Asc,
+        Desc,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum PullRequestState {
+        Closed,
+        Merged,
+        Open,
+    }
+
+    #[derive(cynic::InputObject, Debug)]
+    pub struct IssueOrder {
+        pub direction: OrderDirection,
+        pub field: IssueOrderField,
+    }
+
+    #[derive(cynic::InputObject, Debug)]
+    pub struct IssueCommentOrder {
+        pub direction: OrderDirection,
+        pub field: IssueCommentOrderField,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct Actor {
+        pub login: String,
+    }
+
+    #[derive(cynic::Scalar, Debug, Clone)]
+    pub struct Uri(pub String);
+}
+
+mod schema {
+    cynic::use_schema!("src/github.graphql");
+}

src/github/github.graphql renamed to github-graphql/src/github.graphql

@@ -414,7 +414,7 @@ pub fn prioritization<'a>() -> Box<dyn Action> {
                     QueryMap {
                         name: "top_unreviewed_prs",
                         kind: QueryKind::List,
-                        query: Arc::new(github::graphql::LeastRecentlyReviewedPullRequests),
+                        query: Arc::new(github::LeastRecentlyReviewedPullRequests),
                     },
                 ],
             },

github-graphql/src/lib.rs

@@ -14,8 +14,6 @@ use std::{
 };
 use tracing as log;
 
-pub mod graphql;
-
 #[derive(Debug, PartialEq, Eq, serde::Deserialize)]
 pub struct User {
     pub login: String,
@@ -1487,6 +1485,177 @@ pub trait IssuesQuery {
     ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>>;
 }
 
+pub struct LeastRecentlyReviewedPullRequests;
+#[async_trait]
+impl IssuesQuery for LeastRecentlyReviewedPullRequests {
+    async fn query<'a>(
+        &'a self,
+        repo: &'a Repository,
+        _include_fcp_details: bool,
+        client: &'a GithubClient,
+    ) -> anyhow::Result<Vec<crate::actions::IssueDecorator>> {
+        use cynic::QueryBuilder;
+        use github_graphql::queries;
+
+        let repository_owner = repo.owner().to_owned();
+        let repository_name = repo.name().to_owned();
+
+        let mut prs: Vec<Option<queries::PullRequest>> = vec![];
+
+        let mut args = queries::LeastRecentlyReviewedPullRequestsArguments {
+            repository_owner,
+            repository_name: repository_name.clone(),
+            after: None,
+        };
+        loop {
+            let query = queries::LeastRecentlyReviewedPullRequests::build(&args);
+            let req = client.post(Repository::GITHUB_GRAPHQL_API_URL);
+            let req = req.json(&query);
+
+            let (resp, req_dbg) = client._send_req(req).await?;
+            let response = resp.json().await.context(req_dbg)?;
+            let data: cynic::GraphQlResponse<queries::LeastRecentlyReviewedPullRequests> =
+                query.decode_response(response).with_context(|| {
+                    format!("failed to parse response for `LeastRecentlyReviewedPullRequests`")
+                })?;
+            if let Some(errors) = data.errors {
+                anyhow::bail!("There were graphql errors. {:?}", errors);
+            }
+            let repository = data
+                .data
+                .ok_or_else(|| anyhow::anyhow!("No data returned."))?
+                .repository
+                .ok_or_else(|| anyhow::anyhow!("No repository."))?;
+            prs.extend(
+                repository
+                    .pull_requests
+                    .nodes
+                    .unwrap_or_default()
+                    .into_iter(),
+            );
+            let page_info = repository.pull_requests.page_info;
+            if !page_info.has_next_page || page_info.end_cursor.is_none() {
+                break;
+            }
+            args.after = page_info.end_cursor;
+        }
+
+        let mut prs: Vec<_> = prs
+            .into_iter()
+            .filter_map(|pr| pr)
+            .filter_map(|pr| {
+                if pr.is_draft {
+                    return None;
+                }
+                let labels = pr.labels;
+                let labels = (|| -> Option<_> {
+                    let labels = labels?;
+                    let nodes = labels.nodes?;
+                    let labels = nodes
+                        .into_iter()
+                        .filter_map(|node| node)
+                        .map(|node| node.name)
+                        .collect::<Vec<_>>();
+                    Some(labels)
+                })()
+                .unwrap_or_default();
+                if !labels.iter().any(|label| label == "T-compiler") {
+                    return None;
+                }
+                let labels = labels.join(", ");
+
+                let assignees: Vec<_> = pr
+                    .assignees
+                    .nodes
+                    .unwrap_or_default()
+                    .into_iter()
+                    .filter_map(|user| user)
+                    .map(|user| user.login)
+                    .collect();
+
+                let latest_reviews = pr.latest_reviews;
+                let mut reviews = (|| -> Option<_> {
+                    let reviews = latest_reviews?;
+                    let nodes = reviews.nodes?;
+                    let reviews = nodes
+                        .into_iter()
+                        .filter_map(|node| node)
+                        .filter_map(|node| {
+                            let created_at = node.created_at;
+                            node.author.map(|author| (author, created_at))
+                        })
+                        .map(|(author, created_at)| (author.login, created_at))
+                        .collect::<Vec<_>>();
+                    Some(reviews)
+                })()
+                .unwrap_or_default();
+                reviews.sort_by_key(|r| r.1);
+
+                let comments = pr.comments;
+                let comments = (|| -> Option<_> {
+                    let nodes = comments.nodes?;
+                    let comments = nodes
+                        .into_iter()
+                        .filter_map(|node| node)
+                        .filter_map(|node| {
+                            let created_at = node.created_at;
+                            node.author.map(|author| (author, created_at))
+                        })
+                        .map(|(author, created_at)| (author.login, created_at))
+                        .collect::<Vec<_>>();
+                    Some(comments)
+                })()
+                .unwrap_or_default();
+                let mut comments: Vec<_> = comments
+                    .into_iter()
+                    .filter(|comment| assignees.contains(&comment.0))
+                    .collect();
+                comments.sort_by_key(|c| c.1);
+
+                let updated_at = std::cmp::max(
+                    reviews.last().map(|t| t.1).unwrap_or(pr.created_at),
+                    comments.last().map(|t| t.1).unwrap_or(pr.created_at),
+                );
+                let assignees = assignees.join(", ");
+
+                Some((
+                    updated_at,
+                    pr.number as u64,
+                    pr.title,
+                    pr.url.0,
+                    repository_name.clone(),
+                    labels,
+                    assignees,
+                ))
+            })
+            .collect();
+        prs.sort_by_key(|pr| pr.0);
+
+        let prs: Vec<_> = prs
+            .into_iter()
+            .take(50)
+            .map(
+                |(updated_at, number, title, html_url, repo_name, labels, assignees)| {
+                    let updated_at_hts = crate::actions::to_human(updated_at);
+
+                    crate::actions::IssueDecorator {
+                        number,
+                        title,
+                        html_url,
+                        repo_name,
+                        labels,
+                        assignees,
+                        updated_at_hts,
+                        fcp_details: None,
+                    }
+                },
+            )
+            .collect();
+
+        Ok(prs)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;