Add issueStat query and openIssueCount field

CHANGELOG.md

@@ -11,6 +11,10 @@ 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 GraphQL API: `issueStat` query. Users can filter issues by
+  `assignee`, `author`, `repo`(repository name), `begin` and `end` (creation
+  date range). The query returns the `openIssueCount` field, indicating the
+  number of open issues.
 
 ### Changed
 

Cargo.toml

@@ -15,7 +15,7 @@ directories = "6"
 git2 = "0.20"
 
 graphql_client = "0.14"
-jiff = "0.2"
+jiff = { version = "0.2", features = ["serde"] }
 regex = "1"
 reqwest = { version = "0.12", features = ["json"] }
 serde = { version = "1", features = ["derive"] }

src/database.rs

@@ -7,7 +7,7 @@ use sled::{Db, Tree};
 
 use crate::{
     github::{GitHubIssue, GitHubPullRequests},
-    graphql::{Issue, PullRequest},
+    graphql::{issue::Issue, pull_request::PullRequest},
 };
 const ISSUE_TREE_NAME: &str = "issues";
 const PULL_REQUEST_TREE_NAME: &str = "pull_requests";
@@ -66,11 +66,7 @@ impl Database {
     ) -> Result<()> {
         for item in resp {
             let keystr: String = format!("{owner}/{name}#{}", item.number);
-            Database::insert(
-                &keystr,
-                (&item.title, &item.author, &item.closed_at),
-                &self.issue_tree,
-            )?;
+            Database::insert(&keystr, item, &self.issue_tree)?;
         }
         Ok(())
     }

src/github.rs

@@ -4,12 +4,12 @@
 use graphql_client::{GraphQLQuery, QueryBody, Response as GraphQlResponse};
 use jiff::Timestamp;
 use reqwest::{Client, RequestBuilder, Response};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tokio::time;
 use tracing::error;
 
 use crate::{database::Database, github::{
-    issues::IssuesRepositoryIssuesNodesAuthor::User as userName,
+    issues::{IssueState, IssuesRepositoryIssuesNodesAuthor::User as userName},
     pull_requests::PullRequestsRepositoryPullRequestsNodesReviewRequestsNodesRequestedReviewer::User,
 }, settings::Repository as RepoInfo};
 
@@ -18,15 +18,15 @@
 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 = Timestamp;
 
 #[derive(GraphQLQuery)]
 #[graphql(
     schema_path = "src/github/schema.graphql",
     query_path = "src/github/issues.graphql",
-    response_derives = "Debug"
+    response_derives = "Debug, Clone"
 )]
-struct Issues;
+pub(crate) struct Issues;
 
 #[derive(GraphQLQuery)]
 #[graphql(
@@ -35,12 +35,22 @@
 )]
 struct PullRequests;
 
-#[derive(Debug)]
+#[allow(clippy::derivable_impls)]
+impl Default for IssueState {
+    fn default() -> Self {
+        IssueState::OPEN
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub(super) struct GitHubIssue {
     pub(super) number: i64,
     pub(super) title: String,
     pub(super) author: String,
     pub(super) closed_at: Option<DateTime>,
+    pub(super) created_at: DateTime,
+    pub(super) state: IssueState,
+    pub(super) assignees: Vec<String>,
 }
 
 #[derive(Debug)]
@@ -133,7 +143,7 @@
             last: None,
             before: None,
             after: end_cur,
-            since: Some(since.to_string()),
+            since: Some(since.parse::<DateTime>()?),
         };
         let resp_body: GraphQlResponse<issues::ResponseData> =
             send_query::<Issues>(token, var).await?.json().await?;
@@ -147,11 +157,18 @@
                         if let userName(on_user) = author_ref {
                             author.clone_from(&on_user.login.clone());
                         }
+                        let assignees =
+                            issue.assignees.nodes.as_ref().map_or(Vec::new(), |nodes| {
+                                nodes.iter().flatten().map(|a| a.login.clone()).collect()
+                            });
                         issues.push(GitHubIssue {
                             number: issue.number,
                             title: issue.title.to_string(),
                             author,
-                            closed_at: issue.closed_at.clone(),
+                            closed_at: issue.closed_at,
+                            created_at: issue.created_at,
+                            state: issue.state.clone(),
+                            assignees,
                         });
                     }
                     if !repository.issues.page_info.has_next_page {

src/github/issues.graphql

@@ -35,6 +35,12 @@ query Issues(
             login
           }
         }
+        # TODO: #181
+        assignees(first: 10) {
+          nodes {
+            login
+          }
+        }
       }
     }
   }

src/graphql.rs

@@ -1,16 +1,17 @@
-mod issue;
-mod pull_request;
+pub(crate) mod issue;
+pub(crate) mod issue_stat;
+pub(crate) mod pull_request;
 
 use std::fmt::Display;
 
 use async_graphql::{
     types::connection::{Connection, Edge, EmptyFields},
-    Context, EmptyMutation, EmptySubscription, MergedObject, OutputType, Result,
+    Context, EmptyMutation, EmptySubscription, InputValueError, InputValueResult, MergedObject,
+    OutputType, Result, Scalar, ScalarType, Value,
 };
 use base64::{engine::general_purpose, Engine as _};
+use jiff::Timestamp;
 
-pub(crate) use self::issue::Issue;
-pub(crate) use self::pull_request::PullRequest;
 use crate::database::Database;
 
 /// The default page size for connections when neither `first` nor `last` is
@@ -21,10 +22,31 @@
 ///
 /// This is exposed only for [`Schema`], and not used directly.
 #[derive(Default, MergedObject)]
-pub(crate) struct Query(issue::IssueQuery, pull_request::PullRequestQuery);
+pub(crate) struct Query(
+    issue::IssueQuery,
+    pull_request::PullRequestQuery,
+    issue_stat::IssueStatQuery,
+);
 
 pub(crate) type Schema = async_graphql::Schema<Query, EmptyMutation, EmptySubscription>;
 
+#[derive(Debug)]
+pub(crate) struct DateTimeUtc(Timestamp);
+
+#[Scalar]
+impl ScalarType for DateTimeUtc {
+    fn parse(value: Value) -> InputValueResult<Self> {
+        match &value {
+            Value::String(s) => Ok(DateTimeUtc(s.parse()?)),
+            _ => Err(InputValueError::expected_type(value)),
+        }
+    }
+
+    fn to_value(&self) -> Value {
+        Value::String(self.0.to_string())
+    }
+}
+
 fn connect_cursor<T>(
     select_vec: Vec<T>,
     prev: bool,

src/graphql/issue.rs

@@ -3,10 +3,16 @@ use std::fmt;
 use anyhow::Context as AnyhowContext;
 use async_graphql::{
     connection::{query, Connection, EmptyFields},
-    Context, Object, Result, SimpleObject,
+    scalar, Context, Object, Result, SimpleObject,
 };
 
-use crate::database::{self, Database, TryFromKeyValue};
+use crate::{
+    database::{self, Database, TryFromKeyValue},
+    github::{issues::IssueState, GitHubIssue},
+    graphql::DateTimeUtc,
+};
+
+scalar!(IssueState);
 
 #[derive(SimpleObject)]
 pub(crate) struct Issue {
@@ -15,19 +21,32 @@ pub(crate) struct Issue {
     pub(crate) number: i32,
     pub(crate) title: String,
     pub(crate) author: String,
+    pub(crate) created_at: DateTimeUtc,
+    pub(crate) state: IssueState,
+    pub(crate) assignees: Vec<String>,
 }
 
 impl TryFromKeyValue for Issue {
     fn try_from_key_value(key: &[u8], value: &[u8]) -> anyhow::Result<Self> {
         let (owner, repo, number) = database::parse_key(key)
             .with_context(|| format!("invalid key in database: {key:02x?}"))?;
-        let (title, author, _) = bincode::deserialize::<(String, String, Option<String>)>(value)?;
+        let GitHubIssue {
+            title,
+            author,
+            created_at,
+            state,
+            assignees,
+            ..
+        } = bincode::deserialize::<GitHubIssue>(value)?;
         let issue = Issue {
             title,
             author,
             owner,
             repo,
             number: i32::try_from(number).unwrap_or(i32::MAX),
+            created_at: DateTimeUtc(created_at),
+            state,
+            assignees,
         };
         Ok(issue)
     }
@@ -69,6 +88,15 @@ impl IssueQuery {
 mod tests {
     use crate::{github::GitHubIssue, graphql::TestSchema};
 
+    fn create_issues(n: usize) -> Vec<GitHubIssue> {
+        (1..=n)
+            .map(|i| GitHubIssue {
+                number: i64::try_from(i).unwrap(),
+                ..Default::default()
+            })
+            .collect()
+    }
+
     #[tokio::test]
     async fn issues_empty() {
         let schema = TestSchema::new();
@@ -89,26 +117,7 @@ mod tests {
     #[tokio::test]
     async fn issues_first() {
         let schema = TestSchema::new();
-        let issues = vec![
-            GitHubIssue {
-                number: 1,
-                title: "issue 1".to_string(),
-                author: "author 1".to_string(),
-                closed_at: None,
-            },
-            GitHubIssue {
-                number: 2,
-                title: "issue 2".to_string(),
-                author: "author 2".to_string(),
-                closed_at: None,
-            },
-            GitHubIssue {
-                number: 3,
-                title: "issue 3".to_string(),
-                author: "author 3".to_string(),
-                closed_at: None,
-            },
-        ];
+        let issues = create_issues(3);
         schema.db.insert_issues(issues, "owner", "name").unwrap();
 
         let query = r"
@@ -148,26 +157,7 @@ mod tests {
     #[tokio::test]
     async fn issues_last() {
         let schema = TestSchema::new();
-        let issues = vec![
-            GitHubIssue {
-                number: 1,
-                title: "issue 1".to_string(),
-                author: "author 1".to_string(),
-                closed_at: None,
-            },
-            GitHubIssue {
-                number: 2,
-                title: "issue 2".to_string(),
-                author: "author 2".to_string(),
-                closed_at: None,
-            },
-            GitHubIssue {
-                number: 3,
-                title: "issue 3".to_string(),
-                author: "author 3".to_string(),
-                closed_at: None,
-            },
-        ];
+        let issues = create_issues(3);
         schema.db.insert_issues(issues, "owner", "name").unwrap();
 
         let query = r"