chore(ci): added labeling and notification for published PRs; (axios#…

…6059)

.github/workflows/publish.yml

@@ -53,3 +53,8 @@ jobs:
         run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+      ###### NOTIFY & TAG published PRs ######
+      - name: Notify and tag published PRs
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: node ./bin/actions/notify_published.js --tag v${{ steps.package-version.outputs.current-version }}

bin/GithubAPI.js

@@ -0,0 +1,119 @@
+import util from "util";
+import cp from "child_process";
+import {parseVersion} from "./helpers/parser.js";
+import githubAxios from "./githubAxios.js";
+import memoize from 'memoizee';
+
+const exec = util.promisify(cp.exec);
+
+export default class GithubAPI {
+  constructor(owner, repo) {
+    if (!owner) {
+      throw new Error('repo owner must be specified');
+    }
+
+    if (!repo) {
+      throw new Error('repo must be specified');
+    }
+
+    this.repo = repo;
+    this.owner = owner;
+    this.axios = githubAxios.create({
+      baseURL: `https://api.github.com/repos/${this.owner}/${this.repo}/`,
+    })
+  }
+
+  async createComment(issue, body) {
+    return (await this.axios.post(`/issues/${issue}/comments`, {body})).data;
+  }
+
+  async getComments(issue, {desc = false, per_page= 100, page = 1}) {
+    return (await this.axios.get(`/issues/${issue}/comments`, {params: {direction: desc ? 'desc' : 'asc', per_page, page}})).data;
+  }
+
+  async getComment(id) {
+    return (await this.axios.get(`/issues/comments/${id}`)).data;
+  }
+
+  async updateComment(id, body) {
+    return (await this.axios.patch(`/issues/comments/${id}`, {body})).data;
+  }
+
+  async appendLabels(issue, labels) {
+    return (await this.axios.post(`issues/${issue}/labels`, {labels})).data;
+  }
+
+  async getUser(user) {
+    return (await this.axios.get(`users/${user}`)).data;
+  }
+
+  async isCollaborator(user) {
+    try {
+      return (await this.axios.get(`/collaborators/${user}`)).status === 204;
+    } catch (e) {
+
+    }
+  }
+
+  async deleteLabel(issue, label) {
+    return (await this.axios.delete(`/issues/${issue}/labels/${label}`)).data;
+  }
+
+  async getIssue(issue) {
+    return (await this.axios.get(`/issues/${issue}`)).data;
+  }
+
+  async getPR(issue) {
+    return (await this.axios.get(`/pulls/${issue}`)).data;
+  }
+
+  async getIssues({state= 'open', labels, sort = 'created', desc = false, per_page = 100, page = 1}) {
+    return (await this.axios.get(`/issues`, {params: {state, labels, sort, direction: desc ? 'desc' : 'asc', per_page, page}})).data;
+  }
+
+  async updateIssue(issue, data) {
+    return (await this.axios.patch(`/issues/${issue}`, data)).data;
+  }
+
+  async closeIssue(issue) {
+    return this.updateIssue(issue, {
+      state: "closed"
+    })
+  }
+
+  async getReleases({per_page = 30, page= 1} = {}) {
+    return (await this.axios.get(`/releases`, {params: {per_page, page}})).data;
+  }
+
+  async getRelease(release = 'latest') {
+    return (await this.axios.get(parseVersion(release) ? `/releases/tags/${release}` : `/releases/${release}`)).data;
+  }
+
+  async getTags({per_page = 30, page= 1} = {}) {
+    return (await this.axios.get(`/tags`, {params: {per_page, page}})).data;
+  }
+
+  async reopenIssue(issue) {
+    return this.updateIssue(issue, {
+      state: "open"
+    })
+  }
+
+  static async getTagRef(tag) {
+    try {
+      return (await exec(`git show-ref --tags "refs/tags/${tag}"`)).stdout.split(' ')[0];
+    } catch (e) {
+    }
+  }
+}
+
+const {prototype} = GithubAPI;
+
+['getUser', 'isCollaborator'].forEach(methodName => {
+  prototype[methodName] = memoize(prototype[methodName], { promise: true })
+});
+
+['get', 'post', 'put', 'delete', 'isAxiosError'].forEach((method) => prototype[method] = function(...args){
+  return this.axios[method](...args);
+});
+

bin/RepoBot.js

@@ -0,0 +1,95 @@
+import GithubAPI from "./GithubAPI.js";
+import api from './api.js';
+import Handlebars from "handlebars";
+import fs from "fs/promises";
+import {colorize} from "./helpers/colorize.js";
+import {getReleaseInfo} from "./contributors.js";
+
+const normalizeTag = (tag) => tag.replace(/^v/, '');
+
+class RepoBot {
+  constructor(options) {
+    const {
+      owner, repo,
+      templates
+    } = options || {};
+
+    this.templates = Object.assign({
+      published: '../templates/pr_published.hbs'
+    }, templates);
+
+    this.github = api || new GithubAPI(owner, repo);
+
+    this.owner = this.github.owner;
+    this.repo = this.github.repo;
+  }
+
+  async addComment(targetId, message) {
+    return this.github.createComment(targetId, message);
+  }
+
+  async notifyPRPublished(id, tag) {
+    const pr = await this.github.getPR(id);
+
+    tag = normalizeTag(tag);
+
+    const {merged, labels, user: {login, type}} = pr;
+
+    const isBot = type === 'Bot';
+
+    if (!merged) {
+      return false
+    }
+
+    await this.github.appendLabels(id, ['v' + tag]);
+
+    if (isBot || labels.find(({name}) => name === 'automated pr') || (await this.github.isCollaborator(login))) {
+      return false;
+    }
+
+    const author = await this.github.getUser(login);
+
+    author.isBot = isBot;
+
+    const message = await this.constructor.renderTemplate(this.templates.published, {
+      id,
+      author,
+      release: {
+        tag,
+        url: `https://github.com/${this.owner}/${this.repo}/releases/tag/v${tag}`
+      }
+    });
+
+    return await this.addComment(id, message);
+  }
+
+  async notifyPublishedPRs(tag) {
+    const release = await getReleaseInfo(tag);
+
+    if (!release) {
+      throw Error(colorize()`Can't get release info for ${tag}`);
+    }
+
+    const {merges} = release;
+
+    console.log(colorize()`Found ${merges.length} PRs in ${tag}:`);
+
+    let i = 0;
+
+    for (const pr of merges) {
+      try {
+        console.log(colorize()`${i++}) Notify PR #${pr.id}`)
+        const result = await this.notifyPRPublished(pr.id, tag);
+        console.log(result ? 'OK' : 'Skipped');
+      } catch (err) {
+        console.warn(colorize('green', 'red')`  Failed notify PR ${pr.id}: ${err.message}`);
+      }
+    }
+  }
+
+  static async renderTemplate(template, data) {
+    return Handlebars.compile(String(await fs.readFile(template)))(data);
+  }
+}
+
+export default RepoBot;

bin/actions/notify_published.js

@@ -0,0 +1,22 @@
+import minimist from "minimist";
+import RepoBot from '../RepoBot.js';
+
+const argv = minimist(process.argv.slice(2));
+console.log(argv);
+
+const tag = argv.tag;
+
+if (!tag) {
+  throw new Error('tag must be specified');
+}
+
+const bot = new RepoBot();
+
+(async() => {
+  try {
+    await bot.notifyPublishedPRs(tag);
+  } catch (err) {
+    console.warn('Error:', err.message);
+  }
+})();
+

bin/api.js

@@ -0,0 +1,3 @@
+import GithubAPI from "./GithubAPI.js";
+
+export default new GithubAPI('axios', 'axios');

bin/contributors.js

@@ -1,4 +1,4 @@
-import axios from "./githubAPI.js";
+import axios from "./githubAxios.js";
 import util from "util";
 import cp from "child_process";
 import Handlebars from "handlebars";
@@ -7,6 +7,8 @@ import {colorize} from "./helpers/colorize.js";
 
 const exec = util.promisify(cp.exec);
 
+const ONE_MB = 1024 * 1024;
+
 const removeExtraLineBreaks = (str) => str.replace(/(?:\r\n|\r|\n){3,}/gm, '\r\n\r\n');
 
 const cleanTemplate = template => template
@@ -108,7 +110,11 @@ const getReleaseInfo = ((releaseCache) => async (tag) => {
       version ? '--starting-version ' + version + ' --ending-version ' + version : ''
     } --stdout --commit-limit false --template json`;
 
-  const release = JSON.parse((await exec(command)).stdout)[0];
+  console.log(command);
+
+  const {stdout} = await exec(command, {maxBuffer: 10 * ONE_MB});
+
+  const release = JSON.parse(stdout)[0];
 
   if(release) {
     const authors = {};
@@ -229,6 +235,7 @@ const getTagRef = async (tag) => {
 
 export {
   renderContributorsList,
+  getReleaseInfo,
   renderPRsList,
   getTagRef
 }

bin/helpers/colorize.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 
 export const colorize = (...colors)=> {
   if(!colors.length) {
-    colors = ['green', 'magenta', 'cyan', 'blue', 'yellow', 'red'];
+    colors = ['green', 'cyan', 'magenta', 'blue', 'yellow', 'red'];
   }
 
   const colorsCount = colors.length;

bin/helpers/parser.js

@@ -0,0 +1,12 @@
+export const matchAll = (text, regexp, cb) => {
+  let match;
+  while((match = regexp.exec(text))) {
+    cb(match);
+  }
+}
+
+export const parseSection = (body, name, cb) => {
+  matchAll(body, new RegExp(`^(#+)\\s+${name}?(.*?)^\\1\\s+\\w+`, 'gims'), cb);
+}
+
+export const parseVersion = (rawVersion) => /^v?(\d+).(\d+).(\d+)/.exec(rawVersion);

gulpfile.js

@@ -1,6 +1,6 @@
 import gulp from 'gulp';
 import fs from 'fs-extra';
-import axios from './bin/githubAPI.js';
+import axios from './bin/githubAxios.js';
 import minimist from 'minimist'
 
 const argv = minimist(process.argv.slice(2));