auto/dist/auto.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 __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 __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
            t[p[i]] = s[p[i]];
    return t;
};
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 __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
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;
};
Object.defineProperty(exports, "__esModule", { value: true });
var dotenv_1 = __importDefault(require("dotenv"));
var env_ci_1 = __importDefault(require("env-ci"));
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
var semver_1 = require("semver");
var config_1 = __importDefault(require("./config"));
var git_1 = __importDefault(require("./git"));
var init_1 = __importDefault(require("./init"));
var main_1 = require("./main");
var release_1 = __importStar(require("./release"));
var semver_2 = __importStar(require("./semver"));
var github_token_1 = __importDefault(require("./utils/github-token"));
var load_plugins_1 = __importDefault(require("./utils/load-plugins"));
var logger_1 = __importDefault(require("./utils/logger"));
var make_hooks_1 = require("./utils/make-hooks");
var env = env_ci_1.default();
var loadEnv = function () {
    var envFile = path_1.default.resolve(process.cwd(), '.env');
    if (!fs_1.default.existsSync(envFile)) {
        return;
    }
    var envConfig = dotenv_1.default.parse(fs_1.default.readFileSync(envFile));
    Object.entries(envConfig).forEach(function (_a) {
        var _b = __read(_a, 2), key = _b[0], value = _b[1];
        process.env[key] = value;
    });
};
var Auto = /** @class */ (function () {
    function Auto(args) {
        var _this = this;
        this.prefixRelease = function (release) {
            if (!_this.release) {
                throw _this.createErrorMessage();
            }
            return _this.release.options.noVersionPrefix || release.startsWith('v')
                ? release
                : "v" + release;
        };
        this.args = args;
        this.baseBranch = args.baseBranch || 'master';
        this.logger = logger_1.default(args.veryVerbose ? 'veryVerbose' : args.verbose ? 'verbose' : undefined);
        this.hooks = make_hooks_1.makeHooks();
        this.hooks.onCreateRelease.tap('Link onCreateChangelog', function (release) {
            release.hooks.onCreateChangelog.tap('Link onCreateChangelog', function (changelog) {
                _this.hooks.onCreateChangelog.call(changelog);
            });
        });
        this.hooks.onCreateRelease.tap('Link onCreateLogParse', function (release) {
            release.hooks.onCreateLogParse.tap('Link onCreateLogParse', function (logParse) {
                _this.hooks.onCreateLogParse.call(logParse);
            });
        });
        loadEnv();
    }
    /**
     * Load the .autorc from the file system, set up defaults, combine with CLI args
     * load the extends property, load the plugins and start the git remote interface.
     */
    Auto.prototype.loadConfig = function () {
        return __awaiter(this, void 0, void 0, function () {
            var configLoader, config, _a, _b, _c, repository, token, _d, githubOptions;
            return __generator(this, function (_e) {
                switch (_e.label) {
                    case 0:
                        configLoader = new config_1.default(this.logger);
                        _b = (_a = this.hooks.modifyConfig).call;
                        _c = [{}];
                        return [4 /*yield*/, configLoader.loadConfig(this.args)];
                    case 1:
                        config = _b.apply(_a, [__assign.apply(void 0, _c.concat([(_e.sent()), { baseBranch: this.baseBranch }]))]);
                        this.logger.verbose.success('Loaded `auto` with config:', config);
                        this.config = config;
                        this.labels = config.labels;
                        this.semVerLabels = release_1.getVersionMap(config.labels);
                        this.loadPlugins(config);
                        this.hooks.beforeRun.call(config);
                        return [4 /*yield*/, this.getRepo(config)];
                    case 2:
                        repository = _e.sent();
                        if (!(repository && repository.token)) return [3 /*break*/, 3];
                        _d = repository.token;
                        return [3 /*break*/, 5];
                    case 3: return [4 /*yield*/, github_token_1.default(config.githubApi)];
                    case 4:
                        _d = _e.sent();
                        _e.label = 5;
                    case 5:
                        token = _d;
                        githubOptions = __assign({ owner: config.owner, repo: config.repo }, repository, { token: token, baseUrl: config.githubApi || 'https://api.github.com', graphqlBaseUrl: config.githubGraphqlApi || config.githubApi || 'https://api.github.com' });
                        this.git = this.startGit(githubOptions);
                        this.release = new release_1.default(this.git, config, this.logger);
                        this.hooks.onCreateRelease.call(this.release);
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Interactive prompt for initializing an .autorc
     */
    Auto.prototype.init = function (options) {
        if (options === void 0) { options = {}; }
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, init_1.default(options, this.logger)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Create all of the user's labels on the git remote if the don't already exist
     *
     * @param options Options for the createLabels functionality
     */
    Auto.prototype.createLabels = function (options) {
        if (options === void 0) { options = {}; }
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.release || !this.labels) {
                            throw this.createErrorMessage();
                        }
                        return [4 /*yield*/, this.release.addLabelsToProject(this.labels, options)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Get the labels on a specific PR. Defaults to the labels of the last merged PR
     *
     * @param options Options for the createLabels functionality
     */
    Auto.prototype.label = function (_a) {
        var pr = (_a === void 0 ? {} : _a).pr;
        return __awaiter(this, void 0, void 0, function () {
            var labels, pulls, lastMerged;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.git) {
                            throw this.createErrorMessage();
                        }
                        this.logger.verbose.info("Using command: 'label'");
                        labels = [];
                        if (!!pr) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.git.getPullRequests({
                                state: 'closed'
                            })];
                    case 1:
                        pulls = _b.sent();
                        lastMerged = pulls
                            .sort(function (a, b) {
                            return new Date(b.merged_at).getTime() - new Date(a.merged_at).getTime();
                        })
                            .find(function (pull) { return !!pull.merged_at; });
                        if (lastMerged) {
                            labels = lastMerged.labels.map(function (label) { return label.name; });
                        }
                        return [3 /*break*/, 4];
                    case 2: return [4 /*yield*/, this.git.getLabels(pr)];
                    case 3:
                        labels = _b.sent();
                        _b.label = 4;
                    case 4:
                        if (labels.length) {
                            console.log(labels.join('\n'));
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Create a status on a PR.
     *
     * @param options Options for the pr status functionality
     */
    Auto.prototype.pr = function (_a) {
        var dryRun = _a.dryRun, pr = _a.pr, url = _a.url, options = __rest(_a, ["dryRun", "pr", "url"]);
        return __awaiter(this, void 0, void 0, function () {
            var sha, prNumber, res, target_url, error_1;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.git) {
                            throw this.createErrorMessage();
                        }
                        sha = options.sha;
                        try {
                            prNumber = this.getPrNumber('pr', pr);
                        }
                        catch (error) {
                            // default to sha if no PR found
                        }
                        this.logger.verbose.info("Using command: 'pr'");
                        if (!(!sha && prNumber)) return [3 /*break*/, 2];
                        this.logger.verbose.info('Getting commit SHA from PR.');
                        return [4 /*yield*/, this.git.getPullRequest(prNumber)];
                    case 1:
                        res = _b.sent();
                        sha = res.data.head.sha;
                        return [3 /*break*/, 4];
                    case 2:
                        if (!!sha) return [3 /*break*/, 4];
                        this.logger.verbose.info('No PR found, getting commit SHA from HEAD.');
                        return [4 /*yield*/, this.git.getSha()];
                    case 3:
                        sha = _b.sent();
                        _b.label = 4;
                    case 4:
                        this.logger.verbose.info('Found PR SHA:', sha);
                        target_url = url;
                        if (!!dryRun) return [3 /*break*/, 9];
                        _b.label = 5;
                    case 5:
                        _b.trys.push([5, 7, , 8]);
                        return [4 /*yield*/, this.git.createStatus(__assign({}, options, { sha: sha,
                                target_url: target_url }))];
                    case 6:
                        _b.sent();
                        return [3 /*break*/, 8];
                    case 7:
                        error_1 = _b.sent();
                        throw new Error("Failed to post status to Pull Request with error code " + error_1.status);
                    case 8:
                        this.logger.log.success('Posted status to Pull Request.');
                        return [3 /*break*/, 10];
                    case 9:
                        this.logger.verbose.info('`pr` dry run complete.');
                        _b.label = 10;
                    case 10:
                        this.logger.verbose.success('Finished `pr` command');
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Check that a PR has a SEMVER label. Set a success status on the PR.
     *
     * @param options Options for the pr check functionality
     */
    Auto.prototype.prCheck = function (_a) {
        var dryRun = _a.dryRun, pr = _a.pr, url = _a.url, options = __rest(_a, ["dryRun", "pr", "url"]);
        return __awaiter(this, void 0, void 0, function () {
            var target_url, prNumber, msg, sha, res, labels, labelTexts_1, releaseTag, skipReleaseTag, semverTag, description, error_2, error_3;
            var _this = this;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.git || !this.release || !this.semVerLabels) {
                            throw this.createErrorMessage();
                        }
                        this.logger.verbose.info("Using command: 'pr-check' for '" + url + "'");
                        target_url = url;
                        prNumber = this.getPrNumber('prCheck', pr);
                        _b.label = 1;
                    case 1:
                        _b.trys.push([1, 4, , 5]);
                        return [4 /*yield*/, this.git.getPullRequest(prNumber)];
                    case 2:
                        res = _b.sent();
                        sha = res.data.head.sha;
                        return [4 /*yield*/, this.git.getLabels(prNumber)];
                    case 3:
                        labels = _b.sent();
                        labelTexts_1 = __spread(this.semVerLabels.values());
                        releaseTag = labels.find(function (l) { return l === 'release'; });
                        skipReleaseTag = labels.find(function (l) {
                            return !!_this.release && _this.release.options.skipReleaseLabels.includes(l);
                        });
                        semverTag = labels.find(function (l) {
                            return labelTexts_1.includes(l) &&
                                !!_this.release &&
                                !_this.release.options.skipReleaseLabels.includes(l) &&
                                l !== 'release';
                        });
                        if (semverTag === undefined && !skipReleaseTag) {
                            throw new Error('No semver label!');
                        }
                        this.logger.log.success("PR is using label: " + semverTag);
                        description = void 0;
                        if (skipReleaseTag) {
                            description = 'PR will not create a release';
                        }
                        else if (releaseTag) {
                            description = "PR will create release once merged - " + semverTag;
                        }
                        else {
                            description = "CI - " + semverTag;
                        }
                        msg = {
                            description: description,
                            state: 'success'
                        };
                        return [3 /*break*/, 5];
                    case 4:
                        error_2 = _b.sent();
                        msg = {
                            description: error_2.message,
                            state: 'error'
                        };
                        return [3 /*break*/, 5];
                    case 5:
                        this.logger.verbose.info('Posting status to GitHub\n', msg);
                        if (!!dryRun) return [3 /*break*/, 10];
                        _b.label = 6;
                    case 6:
                        _b.trys.push([6, 8, , 9]);
                        return [4 /*yield*/, this.git.createStatus(__assign({}, options, msg, { target_url: target_url,
                                sha: sha }))];
                    case 7:
                        _b.sent();
                        this.logger.log.success('Posted status to Pull Request.');
                        return [3 /*break*/, 9];
                    case 8:
                        error_3 = _b.sent();
                        throw new Error("Failed to post status to Pull Request with error code " + error_3.status);
                    case 9: return [3 /*break*/, 11];
                    case 10:
                        this.logger.verbose.info('`pr-check` dry run complete.');
                        _b.label = 11;
                    case 11:
                        this.logger.verbose.success('Finished `pr-check` command');
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Comment on a PR. Only one comment will be present on the PR, Older comments are removed.
     * You can use the "context" option to multiple comments on a PR.
     *
     * @param options Options for the comment functionality
     */
    Auto.prototype.comment = function (_a) {
        var message = _a.message, pr = _a.pr, _b = _a.context, context = _b === void 0 ? 'default' : _b, dryRun = _a.dryRun;
        return __awaiter(this, void 0, void 0, function () {
            var prNumber;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        if (!this.git) {
                            throw this.createErrorMessage();
                        }
                        this.logger.verbose.info("Using command: 'comment'");
                        if (!dryRun) return [3 /*break*/, 1];
                        this.logger.log.info("Would have commented on " + pr + " under \"" + context + "\" context:\n\n" + message);
                        return [3 /*break*/, 3];
                    case 1:
                        prNumber = this.getPrNumber('comment', pr);
                        return [4 /*yield*/, this.git.createComment(message, prNumber, context)];
                    case 2:
                        _c.sent();
                        this.logger.log.success("Commented on PR #" + pr);
                        _c.label = 3;
                    case 3: return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Update the body of a PR with a message. Only one message will be present in the PR,
     * Older messages are removed. You can use the "context" option to multiple message
     * in a PR body.
     *
     * @param options Options
     */
    Auto.prototype.prBody = function (_a) {
        var message = _a.message, pr = _a.pr, _b = _a.context, context = _b === void 0 ? 'default' : _b, dryRun = _a.dryRun;
        return __awaiter(this, void 0, void 0, function () {
            var prNumber;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        if (!this.git) {
                            throw this.createErrorMessage();
                        }
                        this.logger.verbose.info("Using command: 'pr-body'");
                        if (!dryRun) return [3 /*break*/, 1];
                        this.logger.log.info("Would have appended to PR body on " + pr + " under \"" + context + "\" context:\n\n" + message);
                        return [3 /*break*/, 3];
                    case 1:
                        prNumber = this.getPrNumber('pr-body', pr);
                        return [4 /*yield*/, this.git.addToPrBody(message, prNumber, context)];
                    case 2:
                        _c.sent();
                        this.logger.log.success("Updated body on PR #" + pr);
                        _c.label = 3;
                    case 3: return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Calculate the version bump for the current state of the repository.
     */
    Auto.prototype.version = function () {
        return __awaiter(this, void 0, void 0, function () {
            var bump;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.logger.verbose.info("Using command: 'version'");
                        return [4 /*yield*/, this.getVersion()];
                    case 1:
                        bump = _a.sent();
                        console.log(bump);
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Calculate the the changelog and commit it.
     */
    Auto.prototype.changelog = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.logger.verbose.info("Using command: 'changelog'");
                        return [4 /*yield*/, this.makeChangelog(options)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Make a release to the git remote with the changes.
     */
    Auto.prototype.runRelease = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.logger.verbose.info("Using command: 'release'");
                        return [4 /*yield*/, this.makeRelease(options)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Auto.prototype.canary = function (options) {
        if (options === void 0) { options = {}; }
        return __awaiter(this, void 0, void 0, function () {
            var preId, build, head, labels, version, canaryVersion, _a, newVersion, result, message, latestTag, commitsInRelease;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.git || !this.release) {
                            throw this.createErrorMessage();
                        }
                        if ('pr' in env && 'build' in env) {
                            preId = env.pr;
                            (build = env.build);
                        }
                        else if ('pr' in env && 'commit' in env) {
                            preId = env.pr;
                            build = env.commit;
                        }
                        preId = options.pr ? String(options.pr) : preId;
                        build = options.build ? String(options.build) : build;
                        return [4 /*yield*/, this.release.getCommitsInRelease('HEAD^')];
                    case 1:
                        head = _b.sent();
                        labels = head.map(function (commit) { return commit.labels; });
                        version = semver_2.calculateSemVerBump(labels, this.semVerLabels, this.config) ||
                            semver_2.default.patch;
                        canaryVersion = '';
                        if (preId) {
                            canaryVersion = canaryVersion + "." + preId;
                        }
                        if (build) {
                            canaryVersion = canaryVersion + "." + build;
                        }
                        if (!!('isPr' in env)) return [3 /*break*/, 3];
                        _a = canaryVersion + ".";
                        return [4 /*yield*/, this.git.getSha(true)];
                    case 2:
                        canaryVersion = _a + (_b.sent());
                        _b.label = 3;
                    case 3:
                        newVersion = '';
                        if (!options.dryRun) return [3 /*break*/, 4];
                        this.logger.log.warn("Published canary identifier would be: \"-canary" + canaryVersion + "\"");
                        return [3 /*break*/, 6];
                    case 4:
                        this.logger.verbose.info('Calling canary hook');
                        return [4 /*yield*/, this.hooks.canary.promise(version, canaryVersion)];
                    case 5:
                        result = _b.sent();
                        if (typeof result === 'object') {
                            this.logger.log.error(result.error);
                            return [2 /*return*/];
                        }
                        newVersion = result;
                        message = options.message || 'Published PR with canary version: `%v`';
                        if (message !== 'false' && env.isCi) {
                            this.prBody({
                                message: message.replace('%v', newVersion),
                                context: 'canary-version'
                            });
                        }
                        this.logger.log.success("Published canary version" + (newVersion ? ": " + newVersion : ''));
                        _b.label = 6;
                    case 6: return [4 /*yield*/, this.git.getLatestTagInBranch()];
                    case 7:
                        latestTag = _b.sent();
                        return [4 /*yield*/, this.release.getCommits(latestTag)];
                    case 8:
                        commitsInRelease = _b.sent();
                        return [2 /*return*/, { newVersion: newVersion, commitsInRelease: commitsInRelease }];
                }
            });
        });
    };
    /**
     * Run the full workflow.
     *
     * 1. Calculate version
     * 2. Make changelog
     * 3. Publish code
     * 4. Create a release
     */
    Auto.prototype.shipit = function (options) {
        if (options === void 0) { options = {}; }
        return __awaiter(this, void 0, void 0, function () {
            var isPR, isBaseBranch, publishInfo, _a, newVersion, commitsInRelease;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        if (!this.git || !this.release) {
                            throw this.createErrorMessage();
                        }
                        this.logger.verbose.info("Using command: 'shipit'");
                        this.hooks.beforeShipIt.call();
                        isPR = 'isPr' in env && env.isPr;
                        isBaseBranch = !isPR && 'branch' in env && env.branch === this.baseBranch;
                        if (!isBaseBranch) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.publishLatest(options)];
                    case 1:
                        _a = _b.sent();
                        return [3 /*break*/, 4];
                    case 2: return [4 /*yield*/, this.canary(options)];
                    case 3:
                        _a = _b.sent();
                        _b.label = 4;
                    case 4:
                        publishInfo = _a;
                        if (!publishInfo) {
                            return [2 /*return*/];
                        }
                        newVersion = publishInfo.newVersion, commitsInRelease = publishInfo.commitsInRelease;
                        return [4 /*yield*/, this.hooks.afterShipIt.promise(newVersion, commitsInRelease)];
                    case 5:
                        _b.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Auto.prototype.getCurrentVersion = function (lastRelease) {
        return __awaiter(this, void 0, void 0, function () {
            var lastVersion;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.hooks.getPreviousVersion.tap('None', function () {
                            _this.logger.veryVerbose.info('No previous release found, using 0.0.0 as previous version.');
                            return _this.prefixRelease('0.0.0');
                        });
                        return [4 /*yield*/, this.hooks.getPreviousVersion.promise(this.prefixRelease)];
                    case 1:
                        lastVersion = _a.sent();
                        if (semver_1.parse(lastRelease) &&
                            semver_1.parse(lastVersion) &&
                            semver_1.gt(lastRelease, lastVersion)) {
                            this.logger.veryVerbose.info('Using latest release as previous version');
                            return [2 /*return*/, lastRelease];
                        }
                        return [2 /*return*/, lastVersion];
                }
            });
        });
    };
    Auto.prototype.publishLatest = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            var version, lastRelease, commitsInRelease, newVersion, current;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.git || !this.release) {
                            throw this.createErrorMessage();
                        }
                        return [4 /*yield*/, this.getVersion()];
                    case 1:
                        version = _a.sent();
                        if (version === '') {
                            this.logger.log.info('No version published.');
                            return [2 /*return*/];
                        }
                        return [4 /*yield*/, this.git.getLatestRelease()];
                    case 2:
                        lastRelease = _a.sent();
                        return [4 /*yield*/, this.release.getCommitsInRelease(lastRelease)];
                    case 3:
                        commitsInRelease = _a.sent();
                        return [4 /*yield*/, this.makeChangelog(options)];
                    case 4:
                        _a.sent();
                        if (!!options.dryRun) return [3 /*break*/, 9];
                        this.logger.verbose.info('Calling version hook');
                        return [4 /*yield*/, this.hooks.version.promise(version)];
                    case 5:
                        _a.sent();
                        this.logger.verbose.info('Calling after version hook');
                        return [4 /*yield*/, this.hooks.afterVersion.promise()];
                    case 6:
                        _a.sent();
                        this.logger.verbose.info('Calling publish hook');
                        return [4 /*yield*/, this.hooks.publish.promise(version)];
                    case 7:
                        _a.sent();
                        this.logger.verbose.info('Calling after publish hook');
                        return [4 /*yield*/, this.hooks.afterPublish.promise()];
                    case 8:
                        _a.sent();
                        _a.label = 9;
                    case 9: return [4 /*yield*/, this.makeRelease(options)];
                    case 10:
                        newVersion = _a.sent();
                        if (!options.dryRun) return [3 /*break*/, 12];
                        this.logger.log.warn("The version reported in the line above hasn't been incremented during `dry-run`");
                        return [4 /*yield*/, this.getCurrentVersion(lastRelease)];
                    case 11:
                        current = _a.sent();
                        if (semver_1.parse(current)) {
                            this.logger.log.warn("Published version would be: " + semver_1.inc(current, version));
                        }
                        _a.label = 12;
                    case 12: return [2 /*return*/, { newVersion: newVersion, commitsInRelease: commitsInRelease }];
                }
            });
        });
    };
    Auto.prototype.getPrNumber = function (command, pr) {
        var envPr = 'pr' in env && Number(env.pr);
        var prNumber = pr || envPr;
        if (!prNumber) {
            throw new Error("Could not detect PR number. " + command + " must be run from either a PR or have the PR number supllied via the --pr flag.");
        }
        return prNumber;
    };
    Auto.prototype.startGit = function (gitOptions) {
        if (!gitOptions.owner || !gitOptions.repo || !gitOptions.token) {
            throw new Error('Must set owner, repo, and GitHub token.');
        }
        this.logger.verbose.info('Options contain repo information.');
        // So that --verbose can be used on public CIs
        var tokenlessArgs = __assign({}, gitOptions, { token: "[Token starting with " + gitOptions.token.substring(0, 4) + "]" });
        this.logger.verbose.info('Initializing GitHub API with:\n', tokenlessArgs);
        return new git_1.default({
            owner: gitOptions.owner,
            repo: gitOptions.repo,
            token: gitOptions.token,
            baseUrl: gitOptions.baseUrl,
            graphqlBaseUrl: gitOptions.graphqlBaseUrl
        }, this.logger);
    };
    Auto.prototype.getVersion = function () {
        return __awaiter(this, void 0, void 0, function () {
            var lastRelease;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.git || !this.release) {
                            throw this.createErrorMessage();
                        }
                        return [4 /*yield*/, this.git.getLatestRelease()];
                    case 1:
                        lastRelease = _a.sent();
                        return [2 /*return*/, this.release.getSemverBump(lastRelease)];
                }
            });
        });
    };
    Auto.prototype.makeChangelog = function (_a) {
        var _b = _a === void 0 ? {} : _a, dryRun = _b.dryRun, from = _b.from, to = _b.to, message = _b.message;
        return __awaiter(this, void 0, void 0, function () {
            var lastRelease, _c, releaseNotes, currentVersion;
            return __generator(this, function (_d) {
                switch (_d.label) {
                    case 0:
                        if (!this.release || !this.git) {
                            throw this.createErrorMessage();
                        }
                        return [4 /*yield*/, this.setGitUser()];
                    case 1:
                        _d.sent();
                        _c = from;
                        if (_c) return [3 /*break*/, 3];
                        return [4 /*yield*/, this.git.getLatestRelease()];
                    case 2:
                        _c = (_d.sent());
                        _d.label = 3;
                    case 3:
                        lastRelease = _c;
                        return [4 /*yield*/, this.release.generateReleaseNotes(lastRelease, to || undefined)];
                    case 4:
                        releaseNotes = _d.sent();
                        this.logger.log.info('New Release Notes\n', releaseNotes);
                        if (dryRun) {
                            this.logger.verbose.info('`changelog` dry run complete.');
                            return [2 /*return*/];
                        }
                        return [4 /*yield*/, this.getCurrentVersion(lastRelease)];
                    case 5:
                        currentVersion = _d.sent();
                        return [4 /*yield*/, this.release.addToChangelog(releaseNotes, lastRelease, currentVersion, message)];
                    case 6:
                        _d.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Auto.prototype.makeRelease = function (_a) {
        var _b = _a === void 0 ? {} : _a, dryRun = _b.dryRun, useVersion = _b.useVersion, slack = _b.slack;
        return __awaiter(this, void 0, void 0, function () {
            var lastRelease, commitsInRelease, releaseNotes, rawVersion, _c, _d, version;
            return __generator(this, function (_e) {
                switch (_e.label) {
                    case 0:
                        if (!this.release || !this.git) {
                            throw this.createErrorMessage();
                        }
                        return [4 /*yield*/, this.git.getLatestRelease()];
                    case 1:
                        lastRelease = _e.sent();
                        // Find base commit or latest release to generate the changelog to HEAD (new tag)
                        this.logger.veryVerbose.info("Using " + lastRelease + " as previous release.");
                        if (lastRelease.match(/^\d+\.\d+\.\d+/)) {
                            lastRelease = this.prefixRelease(lastRelease);
                        }
                        this.logger.log.info('Last used release:', lastRelease);
                        return [4 /*yield*/, this.release.getCommitsInRelease(lastRelease)];
                    case 2:
                        commitsInRelease = _e.sent();
                        return [4 /*yield*/, this.release.generateReleaseNotes(lastRelease)];
                    case 3:
                        releaseNotes = _e.sent();
                        this.logger.log.info("Using release notes:\n" + releaseNotes);
                        _d = useVersion;
                        if (_d) return [3 /*break*/, 5];
                        return [4 /*yield*/, this.getCurrentVersion(lastRelease)];
                    case 4:
                        _d = (_e.sent());
                        _e.label = 5;
                    case 5:
                        _c = _d;
                        if (_c) return [3 /*break*/, 7];
                        return [4 /*yield*/, this.git.getLatestTagInBranch()];
                    case 6:
                        _c = (_e.sent());
                        _e.label = 7;
                    case 7:
                        rawVersion = _c;
                        if (!rawVersion) {
                            this.logger.log.error('Could not calculate next version from last tag.');
                            return [2 /*return*/];
                        }
                        version = semver_1.parse(rawVersion)
                            ? this.prefixRelease(rawVersion)
                            : rawVersion;
                        if (!!dryRun) return [3 /*break*/, 11];
                        this.logger.log.info("Releasing " + version + " to GitHub.");
                        return [4 /*yield*/, this.git.publish(releaseNotes, version)];
                    case 8:
                        _e.sent();
                        if (!(slack || (this.config && this.config.slack))) return [3 /*break*/, 10];
                        this.logger.log.info('Posting release to slack');
                        return [4 /*yield*/, this.release.postToSlack(releaseNotes, version)];
                    case 9:
                        _e.sent();
                        _e.label = 10;
                    case 10: return [3 /*break*/, 12];
                    case 11:
                        this.logger.log.info("Would have released: " + version);
                        _e.label = 12;
                    case 12: return [4 /*yield*/, this.hooks.afterRelease.promise(version, commitsInRelease)];
                    case 13:
                        _e.sent();
                        return [2 /*return*/, version];
                }
            });
        });
    };
    Auto.prototype.createErrorMessage = function () {
        return new Error("Auto is not initialized! Make sure the have run Auto.loadConfig");
    };
    /**
     * Set the git user to make releases and commit with.
     */
    Auto.prototype.setGitUser = function () {
        return __awaiter(this, void 0, void 0, function () {
            var error_4, _a, email, name, packageAuthor;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _b.trys.push([0, 3, , 9]);
                        // If these values are not set git config will exit with an error
                        return [4 /*yield*/, main_1.execPromise('git', ['config', 'user.email'])];
                    case 1:
                        // If these values are not set git config will exit with an error
                        _b.sent();
                        return [4 /*yield*/, main_1.execPromise('git', ['config', 'user.name'])];
                    case 2:
                        _b.sent();
                        return [3 /*break*/, 9];
                    case 3:
                        error_4 = _b.sent();
                        if (!env.isCi) {
                            this.logger.log.note("Detected local environment, will not set git user. This happens automatically in a CI environment.\n\nIf a command fails manually run:\n\n  - git config user.email your@email.com\n  - git config user.name \"Your Name\"");
                            return [2 /*return*/];
                        }
                        if (!this.release) {
                            return [2 /*return*/];
                        }
                        _a = this.release.options, email = _a.email, name = _a.name;
                        return [4 /*yield*/, this.hooks.getAuthor.promise()];
                    case 4:
                        packageAuthor = _b.sent();
                        email = packageAuthor ? packageAuthor.email : email;
                        name = packageAuthor ? packageAuthor.name : name;
                        if (!email) return [3 /*break*/, 6];
                        return [4 /*yield*/, main_1.execPromise('git', ['config', 'user.email', "\"" + email + "\""])];
                    case 5:
                        _b.sent();
                        _b.label = 6;
                    case 6:
                        if (!name) return [3 /*break*/, 8];
                        return [4 /*yield*/, main_1.execPromise('git', ['config', 'user.name', "\"" + name + "\""])];
                    case 7:
                        _b.sent();
                        _b.label = 8;
                    case 8: return [3 /*break*/, 9];
                    case 9: return [2 /*return*/];
                }
            });
        });
    };
    Auto.prototype.getRepo = function (config) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                if (config.owner && config.repo) {
                    return [2 /*return*/, config];
                }
                return [2 /*return*/, this.hooks.getRepository.promise()];
            });
        });
    };
    /**
     * Apply all of the plugins in the config.
     */
    Auto.prototype.loadPlugins = function (config) {
        var _this = this;
        var pluginsPaths = config.plugins || ['npm'];
        pluginsPaths
            .map(function (plugin) {
            return typeof plugin === 'string' ? [plugin, {}] : plugin;
        })
            .map(function (plugin) { return load_plugins_1.default(plugin, _this.logger); })
            .filter(function (plugin) { return !!plugin; })
            .forEach(function (plugin) {
            _this.logger.verbose.info("Using " + plugin.name + " Plugin...");
            plugin.apply(_this);
        });
    };
    return Auto;
}());
exports.default = Auto;
//# sourceMappingURL=auto.js.map