@bconnorwhite/bob/build/commands/release.js

Bob is a toolkit for TypeScript projects

"use strict";

exports.__esModule = true;
exports.getVersion = getVersion;
exports.sendToCoveralls = sendToCoveralls;
exports.release = release;
exports.releaseAction = releaseAction;
exports["default"] = void 0;

var _commanderVersion = require("commander-version");

var _semver = require("semver");

var _inquirer = require("inquirer");

var _configstore = _interopRequireDefault(require("configstore"));

var _conventionalRecommendedBump = _interopRequireDefault(require("conventional-recommended-bump"));

var _exec = require("@bconnorwhite/exec");

var _push = require("./push");

var _prerelease = require("./prerelease");

var _structure = require("../structure");

var _update = require("./update");

var _rest = require("@octokit/rest");

var _coverallsApi = _interopRequireDefault(require("coveralls-api"));

var _utils = require("../utils");

var _hasVersion = _interopRequireDefault(require("has-version"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function getReleaseType() {
  return new Promise(function (resolve) {
    (0, _conventionalRecommendedBump["default"])({
      preset: "angular"
    }, function (_error, _ref) {
      var releaseType = _ref.releaseType;
      resolve(releaseType);
    });
  });
}

var firstVersion = "1.0.0";

function getVersion(_x, _x2, _x3) {
  return _getVersion.apply(this, arguments);
}

function _getVersion() {
  _getVersion = _asyncToGenerator(function* (packageName, version, releaseType) {
    if (packageName === void 0) {
      packageName = "";
    }

    if (version === void 0) {
      version = firstVersion;
    }

    return (0, _hasVersion["default"])(packageName, version).then(function (npmExists) {
      if (npmExists) {
        var _inc;

        return (_inc = (0, _semver.inc)(version, releaseType)) != null ? _inc : firstVersion;
      } else {
        return (0, _exec.exec)("git", ["show-ref", {
          tags: "refs/tags/v" + version
        }], {
          silent: true
        }).then(function (_ref2) {
          var textOutput = _ref2.textOutput;

          if (textOutput) {
            var _inc2;

            return (_inc2 = (0, _semver.inc)(version, releaseType)) != null ? _inc2 : firstVersion;
          } else {
            return version;
          }
        });
      }
    });
  });
  return _getVersion.apply(this, arguments);
}

function getCommitSHA() {
  return _getCommitSHA.apply(this, arguments);
}

function _getCommitSHA() {
  _getCommitSHA = _asyncToGenerator(function* () {
    return (0, _exec.exec)("git", ["rev-parse", "HEAD"], {
      silent: true
    }).then( /*#__PURE__*/function () {
      var _ref3 = _asyncToGenerator(function* (result) {
        return result.textOutput;
      });

      return function (_x7) {
        return _ref3.apply(this, arguments);
      };
    }());
  });
  return _getCommitSHA.apply(this, arguments);
}

function sendToCoveralls(_x4, _x5, _x6) {
  return _sendToCoveralls.apply(this, arguments);
}

function _sendToCoveralls() {
  _sendToCoveralls = _asyncToGenerator(function* (owner, repo, config) {
    return (0, _inquirer.prompt)([{
      type: "input",
      name: "coverallsToken",
      message: "Coveralls token:",
      "default": config == null ? void 0 : config.get("coverallsToken")
    }]).then(function (answers) {
      config == null ? void 0 : config.set("coverallsToken", answers.coverallsToken);
      var coveralls = new _coverallsApi["default"](answers.coverallsToken);
      return coveralls.postJob("github", owner, repo, {
        lcov_path: (0, _structure.getCoverageLCOV)().path
      });
    });
  });
  return _sendToCoveralls.apply(this, arguments);
}

function release() {
  return _release.apply(this, arguments);
}

function _release() {
  _release = _asyncToGenerator(function* () {
    return (0, _prerelease.prerelease)().then( /*#__PURE__*/_asyncToGenerator(function* () {
      return getReleaseType().then( /*#__PURE__*/function () {
        var _ref5 = _asyncToGenerator(function* (releaseType) {
          var pkgJSONFile = (0, _structure.getPackageJSON)();
          return pkgJSONFile.read().then( /*#__PURE__*/function () {
            var _ref6 = _asyncToGenerator(function* (pkgJSON) {
              var oldVersion = pkgJSON == null ? void 0 : pkgJSON.version;
              var version = yield getVersion(pkgJSON == null ? void 0 : pkgJSON.name, oldVersion, releaseType);
              return pkgJSONFile.merge({
                version: version
              }).then( /*#__PURE__*/_asyncToGenerator(function* () {
                return (0, _update.updateChangelog)().then( /*#__PURE__*/_asyncToGenerator(function* () {
                  var tag = "v" + version;
                  return (0, _exec.execAllSeries)([{
                    command: "git",
                    args: ["add", pkgJSONFile.relative, (0, _structure.getChangelog)().relative]
                  }, {
                    command: "git",
                    args: ["commit", {
                      message: tag
                    }]
                  }, {
                    command: "git",
                    args: ["tag", tag]
                  }]).then( /*#__PURE__*/_asyncToGenerator(function* () {
                    return (0, _utils.getModuleName)().then( /*#__PURE__*/function () {
                      var _ref10 = _asyncToGenerator(function* (moduleName) {
                        var config = moduleName ? new _configstore["default"](moduleName) : undefined;
                        return (0, _inquirer.prompt)([{
                          type: "input",
                          name: "githubToken",
                          message: "GitHub token:",
                          "default": config == null ? void 0 : config.get("githubToken")
                        }]).then( /*#__PURE__*/function () {
                          var _ref11 = _asyncToGenerator(function* (answers) {
                            var _getRepoName;

                            config == null ? void 0 : config.set("githubToken", answers.githubToken);
                            var octokit = new _rest.Octokit({
                              auth: answers.githubToken
                            });
                            var repoName = (_getRepoName = (0, _utils.getRepoName)(pkgJSON)) == null ? void 0 : _getRepoName.split("/");

                            if (repoName && repoName.length > 1) {
                              var owner = repoName[0],
                                  repo = repoName[1];
                              var issueNumber;

                              if (version === "1.0.0") {
                                yield octokit.issues.create({
                                  owner: owner,
                                  repo: repo,
                                  title: "Release " + tag
                                }).then(function (response) {
                                  issueNumber = response.data.number;
                                });
                              }

                              yield (0, _push.push)();
                              var sha = yield getCommitSHA();
                              yield sendToCoveralls(owner, repo, config);
                              yield octokit.repos.createCommitStatus({
                                owner: owner,
                                repo: repo,
                                sha: sha,
                                state: "success"
                              });

                              if (issueNumber !== undefined) {
                                return octokit.issues.update({
                                  owner: owner,
                                  repo: repo,
                                  issue_number: issueNumber,
                                  state: "closed"
                                });
                              } else {
                                return undefined;
                              }
                            } else {
                              return undefined;
                            }
                          });

                          return function (_x11) {
                            return _ref11.apply(this, arguments);
                          };
                        }());
                      });

                      return function (_x10) {
                        return _ref10.apply(this, arguments);
                      };
                    }());
                  }));
                }));
              }));
            });

            return function (_x9) {
              return _ref6.apply(this, arguments);
            };
          }());
        });

        return function (_x8) {
          return _ref5.apply(this, arguments);
        };
      }());
    }));
  });
  return _release.apply(this, arguments);
}

function releaseAction() {
  return _releaseAction.apply(this, arguments);
}

function _releaseAction() {
  _releaseAction = _asyncToGenerator(function* () {
    release();
  });
  return _releaseAction.apply(this, arguments);
}

var _default = (0, _commanderVersion.createCommand)("release").description("release to GitHub").action(releaseAction);

exports["default"] = _default;