pcu 0.6.14

A CI tool to update change log in a PR
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#![allow(dead_code)]
use serde::{Deserialize, Serialize};
use tracing::instrument;

use crate::{Client, Error, GraphQLWrapper};

pub(crate) trait GraphQLGetOpenPRs {
    #[allow(async_fn_in_trait)]
    async fn get_open_pull_requests(&self) -> Result<Vec<PrItem>, Error>;
}

#[derive(Deserialize, Debug, Clone)]
struct Data {
    repository: Repository,
}

#[derive(Deserialize, Debug, Clone)]
struct Repository {
    #[serde(skip_deserializing)]
    owner: String,
    #[serde(skip_deserializing)]
    name: String,
    #[serde(rename = "pullRequests")]
    pull_requests: PullRequests,
}

#[derive(Deserialize, Debug, Clone)]
struct PullRequests {
    edges: Vec<Edge>,
}

#[derive(Deserialize, Debug, Clone)]
struct Edge {
    node: PullRequest,
}

#[derive(Deserialize, Debug, Clone)]
struct PullRequest {
    number: i64,
    title: String,
    author: Actor,
}

#[derive(Deserialize, Debug, Clone)]
struct Actor {
    login: String,
}

#[derive(Serialize, Debug, Clone)]
struct Vars {
    owner: String,
    name: String,
}

#[derive(Debug, Clone)]
pub(crate) struct PrItem {
    pub(crate) number: i64,
    title: String,
    pub(crate) login: String,
}

impl GraphQLGetOpenPRs for Client {
    #[instrument(skip(self))]
    async fn get_open_pull_requests(&self) -> Result<Vec<PrItem>, Error> {
        log::trace!("get_open_pull_requests");
        let query = r#"
        query($owner:String!, $name:String!){
            repository(owner: $owner, name: $name) {
                pullRequests(first: 100, states: OPEN) {
                    edges {
                        node {
                            title
                            number
                            author {login}
                            }
                        }
                    }
                }
            }
            "#;

        let vars = Vars {
            owner: self.owner.clone(),
            name: self.repo().to_string(),
        };

        let data_res = self
            .github_graphql
            .query_with_vars_unwrap::<Data, Vars>(query, vars)
            .await;

        log::trace!("data_res: {data_res:?}");

        let data = data_res.map_err(GraphQLWrapper::from)?;

        log::trace!("data: {data:?}");

        let edges = data
            .repository
            .pull_requests
            .edges
            .iter()
            .map(|pr| PrItem {
                number: pr.node.number,
                title: pr.node.title.clone(),
                login: pr.node.author.login.clone(),
            })
            .collect();

        Ok(edges)
    }
}