react/scripts/release-manager/commands/stable-prs.js

'use strict';

const chalk = require('chalk');
const pify = require('pify');

const git = require('./utils/git');

const SEMVER_LABELS = [
  'semver-major',
  'semver-minor',
  'semver-patch',
  'semver-exempt',
];

module.exports = function(vorpal, app) {
  vorpal
    .command('stable-prs')
    .description(
      'Get list of stable pull requests that need to be merged to the stable branch'
    )
    .action(function(args) {
      // This makes the chaining easier but obfuscates the actual API, which is
      // unfortunate. The standalone API will return the right data but
      // promisified will get the response object and then we need to pull data
      // off of that.
      let listMilestones = pify(app.ghissues.listMilestones.bind(app.ghissues));
      let listIssues = pify(app.ghissues.listIssues.bind(app.ghissues));
      let editIssue = pify(app.ghissues.editIssue.bind(app.ghissues));
      let getPullRequest = pify(app.ghrepo.getPullRequest.bind(app.ghrepo));

      let targetMilestone = null;

      return new Promise((resolveAction, rejectAction) => {
        listMilestones(null)
          .then(milestones => {
            app.writeTo('milestones.json', milestones);

            // Turn the milestones into choices for Inquirer
            let milestoneChoices = milestones.map(milestone => {
              return {
                value: milestone.number,
                name: milestone.title,
              };
            });

            // We need label choices too
            let labelChoices = SEMVER_LABELS.map(label => {
              return {
                value: label,
                name: label.split('-')[1], // "major" instead of "semver-major"
              };
            });

            // Ask about source milestone
            // Ask about dest milestone
            // TODO: allow creation of milestone here.
            // Ask about which labels to pull from

            return this.prompt([
              {
                name: 'srcMilestone',
                type: 'list',
                message: 'Which milestone should we pull PRs from?',
                choices: milestoneChoices,
              },
              {
                name: 'destMilestone',
                type: 'list',
                message: 'Which milestone should we assign PRs to upon completion?',
                choices: milestoneChoices,
              },
              {
                name: 'labels',
                type: 'checkbox',
                message: 'Which PRs should we select (use spacebar to check all that apply)',
                choices: labelChoices,
              },
            ]).then(answers => {
              // this.log(JSON.stringify(answers, null, 2));
              targetMilestone = answers.destMilestone;
              let labels = {};
              answers.labels.forEach(label => {
                labels[label] = true;
              });
              return {
                labels: labels,
                query: {
                  milestone: answers.srcMilestone,
                  per_page: 100,
                  state: 'closed',
                },
              };
            });
          })
          // Request issues, filter to applicable PRs
          .then(({labels, query}) => {
            return (
              listIssues(query)
                .then(issues => {
                  app.writeTo('stable-issues.json', issues);

                  // This API *could* return issues that aren't pull requests, so filter out
                  // issues that don't have pull_request set. Also filter out issues that
                  // aren't the right level of semver (eg if running a patch release)
                  let filteringLabels = Object.keys(labels).length > 0;
                  const pulls = issues.filter(issue => {
                    if (!issue.pull_request) {
                      return false;
                    }

                    if (!filteringLabels) {
                      return true;
                    }

                    return issue.labels.some(label => labels[label.name]);
                  });
                  app.writeTo('stable-prs.json', pulls);
                  return pulls;
                })
                // We need to convert the issues to PRs. We don't actually have enough
                // info for the pull request data, so we need to get more. Then we'll
                // do some filtering and sorting to make sure we apply merged PRs in
                // the order they were originally committed to avoid conflicts as much
                // as possible.
                .then(pulls => {
                  return Promise.all(
                    pulls.map(pr => {
                      return getPullRequest(pr.number).then(richPR => {
                        app.writeTo(`pr-${pr.number}.json`, richPR);
                        richPR.__originalIssue = pr;
                        return richPR;
                      });
                    })
                  ).then(richPRs => {
                    return richPRs
                      .filter(pr => {
                        if (!pr.merged_at) {
                          this.log(
                            `${chalk.yellow.bold('WARNING')} ${pr.html_url} was not merged,` +
                              ` should have the milestone unset.`
                          );
                          return false;
                        }
                        return true;
                      })
                      .map(pr => {
                        pr.merged_at_date = new Date(pr.merged_at);
                        return pr;
                      })
                      .sort((a, b) => a.merged_at_date - b.merged_at_date);
                  });
                })
            );
          })
          // Quick prompt to double check that we should proceed.
          .then(pulls => {
            this.log(`Found ${chalk.bold(pulls.length)} pull requests:`);
            pulls.forEach(pr => {
              this.log(`${pr.html_url}: ${chalk.bold(pr.title)}`);
            });

            return this.prompt({
              name: 'merge',
              type: 'confirm',
              message: `Merge these ${pulls.length} pull requests?`,
            }).then(answers => {
              return answers.merge ? pulls : rejectAction('cancelled');
            });
          })
          // Ok, now we finally have rich pull request data. We can start cherry picking…
          .then(pulls => {
            // We're going to do some error handling here so we don't get into a
            // terrible state.
            this.log(`Found ${chalk.bold(pulls.length)} pull requests:`);
            return new Promise((resolve, reject) => {
              cherryPickPRs
                .call(this, app, pulls)
                .then(results => {
                  resolve(results);
                })
                .catch(err => {
                  this.log(
                    `${chalk.red.bold('ERROR')} Something went wrong and your repo is` +
                      ` probably in a bad state. Sorry.`
                  );
                  resolve({
                    successful: [],
                    skipped: [],
                    didAbort: true,
                  });
                });
            });
          })
          // Update the milestone on successful PRs
          // TODO: maybe handle didAbort and git reset --hard to a rev we read when we start the process?
          .then(({successful, aborted, didAbort}) => {
            if (didAbort) {
              return undefined;
            }

            return Promise.all(
              successful.map(pr => {
                return editIssue(pr.number, {milestone: targetMilestone});
              })
            );
          })
          // yay, we're done
          .then(() => {
            resolveAction();
          })
          .catch(err => {
            this.log('ERROR', err);
            rejectAction();
          });
      });
    });
};

function cherryPickPRs(app, prs) {
  let successful = [];
  let skipped = [];
  return new Promise((resolve, reject) => {
    // Build array of thenables
    let promises = prs.map(pr => {
      return () =>
        new Promise((res, rej) => {
          this.log(
            chalk.yellow(`Cherry-picking #${pr.number} (${pr.title})...`)
          );
          let failed = false;
          try {
            git.cherryPickMerge(app, pr.merge_commit_sha);
          } catch (e) {
            failed = true;
          }

          if (!failed) {
            this.log(chalk.green`Success`);
            successful.push(pr);
            return res();
          }

          return this.prompt({
            name: 'handle',
            type: 'list',
            message: `${chalk.red`Failed!`} ${chalk.yellow('This must be resolved manually!')}`,
            choices: [
              {value: 'ok', name: 'Continue, mark successful'},
              {value: 'skip', name: 'Continue, mark skipped'},
              {
                value: 'abort',
                name: 'Abort process. Will require manual resetting of git state.',
              },
            ],
          }).then(answers => {
            switch (answers.handle) {
              case 'ok':
                successful.push(pr);
                break;
              case 'skip':
                skipped.push(pr);
                break;
              case 'abort':
                return rej(pr.number);
            }
            res(pr.number);
          });
        });
    });

    // Since promises run on creation and we don't actually want that, we create
    // an array of functions that return promises. We'll chain them here, not
    // actually creating the next promise until we're ready.
    var p = promises[0]();
    for (let i = 1; i < promises.length; i++) {
      p = p.then(() => promises[i]());
    }
    p
      .then(() => {
        resolve({successful, skipped, didAbort: false});
      })
      .catch(e => {
        resolve({successful, skipped, didAbort: true});
      });
  });
}