auto/dist/release.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var _a;
var fs = __importStar(require("fs"));
var semver_1 = require("semver");
var util_1 = require("util");
var typescript_memoize_1 = require("typescript-memoize");
var changelog_1 = __importDefault(require("./changelog"));
var log_parse_1 = __importDefault(require("./log-parse"));
var semver_2 = __importStar(require("./semver"));
var exec_promise_1 = __importDefault(require("./utils/exec-promise"));
var logger_1 = require("./utils/logger");
var make_hooks_1 = require("./utils/make-hooks");
var slack_1 = __importDefault(require("./utils/slack"));
exports.defaultLabels = [
    semver_2.default.major,
    semver_2.default.minor,
    semver_2.default.patch,
    'skip-release',
    'release',
    'prerelease'
];
exports.isVersionLabel = function (label) {
    return exports.defaultLabels.includes(label);
};
exports.defaultLabelDefinition = (_a = {},
    _a[semver_2.default.major] = {
        name: 'major',
        title: '💥  Breaking Change',
        description: 'Increment the major version when merged'
    },
    _a[semver_2.default.minor] = {
        name: 'minor',
        title: '🚀  Enhancement',
        description: 'Increment the minor version when merged'
    },
    _a[semver_2.default.patch] = {
        name: 'patch',
        title: '🐛  Bug Fix',
        description: 'Increment the patch version when merged'
    },
    _a['skip-release'] = {
        name: 'skip-release',
        description: 'Preserve the current version when merged'
    },
    _a.release = {
        name: 'release',
        description: 'Create a release when this pr is merged'
    },
    _a.prerelease = {
        name: 'prerelease',
        title: '🚧 Prerelease',
        description: 'Create a pre-release version when merged'
    },
    _a.internal = {
        name: 'internal',
        title: '🏠  Internal',
        description: 'Changes only affect the internal API'
    },
    _a.documentation = {
        name: 'documentation',
        title: '📝  Documentation',
        description: 'Changes only affect the documentation'
    },
    _a);
exports.getVersionMap = function (labels) {
    if (labels === void 0) { labels = exports.defaultLabelDefinition; }
    return Object.entries(labels).reduce(function (semVer, _a) {
        var _b = __read(_a, 2), label = _b[0], labelDef = _b[1];
        if (exports.isVersionLabel(label)) {
            semVer.set(label, labelDef.name);
        }
        return semVer;
        // tslint:disable-next-line align
    }, new Map());
};
var readFile = util_1.promisify(fs.readFile);
var writeFile = util_1.promisify(fs.writeFile);
/**
 * A class for interacting with the git remote
 */
var Release = /** @class */ (function () {
    function Release(git, options, logger) {
        if (options === void 0) { options = {
            skipReleaseLabels: [],
            labels: exports.defaultLabelDefinition
        }; }
        if (logger === void 0) { logger = logger_1.dummyLog(); }
        this.options = options;
        this.logger = logger;
        this.hooks = make_hooks_1.makeReleaseHooks();
        this.versionLabels = exports.getVersionMap(options.labels);
        this.git = git;
    }
    /**
     * Generate a changelog from a range of commits.
     *
     * @param from sha or tag to start changelog from
     * @param to sha or tag to end changelog at (defaults to HEAD)
     */
    Release.prototype.generateReleaseNotes = function (from, to) {
        if (to === void 0) { to = 'HEAD'; }
        return __awaiter(this, void 0, void 0, function () {
            var commits, project, changelog;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getCommitsInRelease(from, to)];
                    case 1:
                        commits = _a.sent();
                        return [4 /*yield*/, this.git.getProject()];
                    case 2:
                        project = _a.sent();
                        changelog = new changelog_1.default(this.logger, {
                            owner: this.git.options.owner,
                            repo: this.git.options.repo,
                            baseUrl: project.html_url,
                            jira: this.options.jira,
                            labels: this.options.labels
                        });
                        this.hooks.onCreateChangelog.call(changelog);
                        changelog.loadDefaultHooks();
                        return [2 /*return*/, changelog.generateReleaseNotes(commits)];
                }
            });
        });
    };
    Release.prototype.getCommitsInRelease = function (from, to) {
        if (to === void 0) { to = 'HEAD'; }
        return __awaiter(this, void 0, void 0, function () {
            var allCommits, allPrCommits, allPrCommitHashes, labelled;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getCommits(from, to)];
                    case 1:
                        allCommits = _a.sent();
                        return [4 /*yield*/, Promise.all(allCommits
                                .filter(function (commit) { return commit.pullRequest; })
                                .map(function (commit) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.git.getCommitsForPR(Number(commit.pullRequest.number))];
                            }); }); }))];
                    case 2:
                        allPrCommits = _a.sent();
                        allPrCommitHashes = allPrCommits
                            .filter(Boolean)
                            .reduce(function (all, pr) { return __spread(all, pr.map(function (subCommit) { return subCommit.sha; })); }, []);
                        labelled = allCommits.filter(function (commit) {
                            return !allPrCommitHashes.includes(commit.hash) &&
                                !commit.subject.includes('[skip ci]');
                        });
                        return [4 /*yield*/, Promise.all(labelled.map(function (commit) { return __awaiter(_this, void 0, void 0, function () {
                                var prs, labels;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0:
                                            if (commit.pullRequest) {
                                                return [2 /*return*/, commit];
                                            }
                                            return [4 /*yield*/, this.git.searchRepo({ q: commit.hash })];
                                        case 1:
                                            prs = _a.sent();
                                            if (prs && prs.items && prs.total_count > 0) {
                                                labels = prs.items[0].labels || [];
                                                commit.labels = __spread(labels.map(function (label) { return label.name; }), commit.labels);
                                            }
                                            else {
                                                commit.labels = __spread(['pushToMaster'], commit.labels);
                                            }
                                            commit.subject = commit.subject.split('\n')[0];
                                            return [2 /*return*/];
                                    }
                                });
                            }); }))];
                    case 3:
                        _a.sent();
                        return [2 /*return*/, labelled];
                }
            });
        });
    };
    /**
     * Prepend a set of release notes to the changelog.md
     *
     * @param releaseNotes Release notes to prepend to the changelog
     * @param lastRelease Last release version of the code. Could be the first commit SHA
     * @param currentVersion Current version of the code
     * @param message Message to commit the changelog with
     */
    Release.prototype.addToChangelog = function (releaseNotes, lastRelease, currentVersion, message) {
        if (message === void 0) { message = 'Update CHANGELOG.md [skip ci]'; }
        return __awaiter(this, void 0, void 0, function () {
            var version, bump, date, prefixed, newChangelog, oldChangelog;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.logger.verbose.info('Adding new changes to changelog.');
                        if (!lastRelease.match(/\d+\.\d+\.\d+/)) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.calcNextVersion(lastRelease)];
                    case 1:
                        version = _a.sent();
                        return [3 /*break*/, 4];
                    case 2: return [4 /*yield*/, this.getSemverBump(lastRelease)];
                    case 3:
                        bump = _a.sent();
                        version = semver_1.inc(currentVersion, bump);
                        _a.label = 4;
                    case 4:
                        this.logger.verbose.info('Calculated next version to be:', version);
                        date = new Date().toDateString();
                        prefixed = this.options.noVersionPrefix || (version && version.startsWith('v'))
                            ? version
                            : "v" + version;
                        newChangelog = "# " + prefixed + " (" + date + ")\n\n" + releaseNotes;
                        if (!fs.existsSync('CHANGELOG.md')) return [3 /*break*/, 6];
                        this.logger.verbose.info('Old changelog exists, prepending changes.');
                        return [4 /*yield*/, readFile('CHANGELOG.md', 'utf8')];
                    case 5:
                        oldChangelog = _a.sent();
                        newChangelog = newChangelog + "\n\n---\n\n" + oldChangelog;
                        _a.label = 6;
                    case 6: return [4 /*yield*/, writeFile('CHANGELOG.md', newChangelog)];
                    case 7:
                        _a.sent();
                        this.logger.verbose.info('Wrote new changelog to filesystem.');
                        return [4 /*yield*/, exec_promise_1.default('git', ['add', 'CHANGELOG.md'])];
                    case 8:
                        _a.sent();
                        return [4 /*yield*/, exec_promise_1.default('git', ['commit', '-m', "\"" + message + "\"", '--no-verify'])];
                    case 9:
                        _a.sent();
                        this.logger.verbose.info('Commited new changelog.');
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Get a range of commits. The commits will have PR numbers and labels attached
     *
     * @param from Tag or SHA to start at
     * @param to Tage or SHA to end at (defaults to HEAD)
     */
    Release.prototype.getCommits = function (from, to) {
        if (to === void 0) { to = 'HEAD'; }
        return __awaiter(this, void 0, void 0, function () {
            var gitlog, logParse, commits;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.logger.verbose.info("Getting commits from " + from + " to " + to);
                        return [4 /*yield*/, this.git.getGitLog(from, to)];
                    case 1:
                        gitlog = _a.sent();
                        this.logger.veryVerbose.info('Got gitlog:\n', gitlog);
                        return [4 /*yield*/, this.createLogParse()];
                    case 2:
                        logParse = _a.sent();
                        return [4 /*yield*/, logParse.normalizeCommits(gitlog)];
                    case 3:
                        commits = _a.sent();
                        this.logger.veryVerbose.info('Added labels to commits:\n', commits);
                        return [4 /*yield*/, Promise.all(commits.map(function (commit) { return __awaiter(_this, void 0, void 0, function () {
                                var resolvedAuthors, prCommits, author;
                                var _this = this;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0:
                                            resolvedAuthors = [];
                                            if (!commit.pullRequest) return [3 /*break*/, 3];
                                            return [4 /*yield*/, this.git.getCommitsForPR(Number(commit.pullRequest.number))];
                                        case 1:
                                            prCommits = _a.sent();
                                            if (!prCommits) {
                                                return [2 /*return*/];
                                            }
                                            return [4 /*yield*/, Promise.all(prCommits.map(function (prCommit) { return __awaiter(_this, void 0, void 0, function () {
                                                    return __generator(this, function (_a) {
                                                        if (prCommit && prCommit.author) {
                                                            return [2 /*return*/, this.git.getUserByUsername(prCommit.author.login)];
                                                        }
                                                        return [2 /*return*/];
                                                    });
                                                }); }))];
                                        case 2:
                                            resolvedAuthors = _a.sent();
                                            return [3 /*break*/, 5];
                                        case 3:
                                            if (!commit.authorEmail) return [3 /*break*/, 5];
                                            return [4 /*yield*/, this.git.getUserByEmail(commit.authorEmail)];
                                        case 4:
                                            author = _a.sent();
                                            resolvedAuthors.push(author);
                                            _a.label = 5;
                                        case 5:
                                            commit.authors = resolvedAuthors.map(function (author) { return (__assign({}, author, { username: author ? author.login : undefined })); });
                                            commit.authors.map(function (author) {
                                                _this.logger.veryVerbose.info("Found author: " + author.username);
                                            });
                                            return [2 /*return*/];
                                    }
                                });
                            }); }))];
                    case 4:
                        _a.sent();
                        return [2 /*return*/, commits];
                }
            });
        });
    };
    Release.prototype.addLabelsToProject = function (labels, options) {
        if (options === void 0) { options = {}; }
        return __awaiter(this, void 0, void 0, function () {
            var oldLabels, labelsToCreate, repoMetadata, justLabelNames, state, state;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.git.getProjectLabels()];
                    case 1:
                        oldLabels = _a.sent();
                        labelsToCreate = Object.entries(labels).filter(function (_a) {
                            var _b = __read(_a, 2), versionLabel = _b[0], labelDef = _b[1];
                            if (!labelDef) {
                                return;
                            }
                            if (versionLabel === 'release' &&
                                !_this.options.onlyPublishWithReleaseLabel) {
                                return;
                            }
                            if (versionLabel === 'skip-release' &&
                                _this.options.onlyPublishWithReleaseLabel) {
                                return;
                            }
                            return true;
                        });
                        if (!!options.dryRun) return [3 /*break*/, 3];
                        return [4 /*yield*/, Promise.all(labelsToCreate.map(function (_a) {
                                var _b = __read(_a, 2), label = _b[0], labelDef = _b[1];
                                return __awaiter(_this, void 0, void 0, function () {
                                    return __generator(this, function (_c) {
                                        switch (_c.label) {
                                            case 0:
                                                if (!labelDef) {
                                                    return [2 /*return*/];
                                                }
                                                if (!(oldLabels && oldLabels.includes(labelDef.name))) return [3 /*break*/, 2];
                                                return [4 /*yield*/, this.git.updateLabel(label, labelDef)];
                                            case 1:
                                                _c.sent();
                                                return [3 /*break*/, 4];
                                            case 2: return [4 /*yield*/, this.git.createLabel(label, labelDef)];
                                            case 3:
                                                _c.sent();
                                                _c.label = 4;
                                            case 4: return [2 /*return*/];
                                        }
                                    });
                                });
                            }))];
                    case 2:
                        _a.sent();
                        _a.label = 3;
                    case 3: return [4 /*yield*/, this.git.getProject()];
                    case 4:
                        repoMetadata = _a.sent();
                        justLabelNames = labelsToCreate.map(function (_a) {
                            var _b = __read(_a, 1), name = _b[0];
                            return name;
                        });
                        if (justLabelNames.length > 0) {
                            state = options.dryRun ? 'Would have created' : 'Created';
                            this.logger.log.log(state + " labels: " + justLabelNames.join(', '));
                        }
                        else {
                            state = options.dryRun ? 'would have been' : 'were';
                            this.logger.log.log("No labels " + state + " created, they must have already been present on your project.");
                        }
                        if (options.dryRun) {
                            return [2 /*return*/];
                        }
                        this.logger.log.log("\nYou can see these, and more at " + repoMetadata.html_url + "/labels");
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Calculate the SEMVER bump over a range of commits using the PR labels
     *
     * @param from Tag or SHA to start at
     * @param to Tage or SHA to end at (defaults to HEAD)
     */
    Release.prototype.getSemverBump = function (from, to) {
        if (to === void 0) { to = 'HEAD'; }
        return __awaiter(this, void 0, void 0, function () {
            var commits, labels, _a, onlyPublishWithReleaseLabel, skipReleaseLabels, options, result;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4 /*yield*/, this.getCommits(from, to)];
                    case 1:
                        commits = _b.sent();
                        labels = commits.map(function (commit) { return commit.labels; });
                        _a = this.options, onlyPublishWithReleaseLabel = _a.onlyPublishWithReleaseLabel, skipReleaseLabels = _a.skipReleaseLabels;
                        options = { onlyPublishWithReleaseLabel: onlyPublishWithReleaseLabel, skipReleaseLabels: skipReleaseLabels };
                        this.logger.verbose.info('Calculating SEMVER bump using:\n', {
                            labels: labels,
                            versionLabels: this.versionLabels,
                            options: options
                        });
                        result = semver_2.calculateSemVerBump(labels, this.versionLabels, options);
                        this.logger.verbose.success('Calculated SEMVER bump:', result);
                        return [2 /*return*/, result];
                }
            });
        });
    };
    /**
     * Post the release notes to slack.
     *
     * @param releaseNotes Release notes to post to slack
     * @param tag Version to include in the title of the slack message
     */
    Release.prototype.postToSlack = function (releaseNotes, tag) {
        return __awaiter(this, void 0, void 0, function () {
            var project;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.options.slack) {
                            throw new Error('Slack url must be set to post a message to slack.');
                        }
                        return [4 /*yield*/, this.git.getProject()];
                    case 1:
                        project = _a.sent();
                        this.logger.verbose.info('Posting release notes to slack.');
                        return [4 /*yield*/, slack_1.default(releaseNotes, {
                                tag: tag,
                                owner: this.git.options.owner,
                                repo: this.git.options.repo,
                                baseUrl: project.html_url,
                                slackUrl: this.options.slack
                            })];
                    case 2:
                        _a.sent();
                        this.logger.verbose.info('Posted release notes to slack.');
                        return [2 /*return*/];
                }
            });
        });
    };
    Release.prototype.calcNextVersion = function (lastTag) {
        return __awaiter(this, void 0, void 0, function () {
            var bump;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getSemverBump(lastTag)];
                    case 1:
                        bump = _a.sent();
                        return [2 /*return*/, semver_1.inc(lastTag, bump)];
                }
            });
        });
    };
    Release.prototype.createLogParse = function () {
        return __awaiter(this, void 0, void 0, function () {
            var logParse;
            var _this = this;
            return __generator(this, function (_a) {
                logParse = new log_parse_1.default();
                logParse.hooks.parseCommit.tapPromise('Labels', function (commit) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                    return [2 /*return*/, this.addLabelsToCommit(commit)];
                }); }); });
                logParse.hooks.parseCommit.tapPromise('PR Commits', function (commit) { return __awaiter(_this, void 0, void 0, function () {
                    var prsSinceLastRelease;
                    return __generator(this, function (_a) {
                        switch (_a.label) {
                            case 0: return [4 /*yield*/, this.getPRsSinceLastRelease()];
                            case 1:
                                prsSinceLastRelease = _a.sent();
                                return [2 /*return*/, this.getPRForRebasedCommits(commit, prsSinceLastRelease)];
                        }
                    });
                }); });
                this.hooks.onCreateLogParse.call(logParse);
                return [2 /*return*/, logParse];
            });
        });
    };
    Release.prototype.getPRsSinceLastRelease = function () {
        return __awaiter(this, void 0, void 0, function () {
            var lastRelease, error_1, firstCommit, _a, prsSinceLastRelease, data;
            var _this = this;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _b.trys.push([0, 2, , 5]);
                        return [4 /*yield*/, this.git.getLatestReleaseInfo()];
                    case 1:
                        lastRelease = _b.sent();
                        return [3 /*break*/, 5];
                    case 2:
                        error_1 = _b.sent();
                        return [4 /*yield*/, this.git.getFirstCommit()];
                    case 3:
                        firstCommit = _b.sent();
                        _a = {};
                        return [4 /*yield*/, this.git.getCommitDate(firstCommit)];
                    case 4:
                        lastRelease = (_a.published_at = _b.sent(),
                            _a);
                        return [3 /*break*/, 5];
                    case 5:
                        if (!lastRelease) {
                            return [2 /*return*/, []];
                        }
                        return [4 /*yield*/, this.git.searchRepo({
                                q: "is:pr is:merged merged:>=" + lastRelease.published_at
                            })];
                    case 6:
                        prsSinceLastRelease = _b.sent();
                        if (!prsSinceLastRelease || !prsSinceLastRelease.items) {
                            return [2 /*return*/, []];
                        }
                        return [4 /*yield*/, Promise.all(prsSinceLastRelease.items.map(function (pr) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                return [2 /*return*/, this.git.getPullRequest(Number(pr.number))];
                            }); }); }))];
                    case 7:
                        data = _b.sent();
                        return [2 /*return*/, data.map(function (item) { return item.data; })];
                }
            });
        });
    };
    /**
     * Add the PR labels to the commit
     *
     * @param commits Commits to modify
     */
    Release.prototype.addLabelsToCommit = function (commit) {
        return __awaiter(this, void 0, void 0, function () {
            var labels;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!commit.labels) {
                            commit.labels = [];
                        }
                        if (!commit.pullRequest) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.git.getLabels(commit.pullRequest.number)];
                    case 1:
                        labels = (_a.sent()) || [];
                        commit.labels = __spread(labels, commit.labels);
                        _a.label = 2;
                    case 2: return [2 /*return*/, commit];
                }
            });
        });
    };
    /**
     * Commits from rebased PRs do not have messages that tie them to a PR
     * Instead we have to find all PRs since the last release and try to match
     * their merge commit SHAs.
     *
     * @param commits Commits to modify
     */
    Release.prototype.getPRForRebasedCommits = function (commit, pullRequests) {
        var matchPr = pullRequests.find(function (pr) { return pr.merge_commit_sha === commit.hash; });
        if (!commit.pullRequest && matchPr) {
            var labels = matchPr.labels.map(function (label) { return label.name; }) || [];
            commit.labels = __spread(labels, commit.labels);
            commit.pullRequest = {
                number: matchPr.number
            };
        }
        return commit;
    };
    __decorate([
        typescript_memoize_1.Memoize()
    ], Release.prototype, "createLogParse", null);
    __decorate([
        typescript_memoize_1.Memoize()
    ], Release.prototype, "getPRsSinceLastRelease", null);
    return Release;
}());
exports.default = Release;
//# sourceMappingURL=release.js.map