smooth-release/lib/npm/publish.js

Smart CLI tool to safely and automatically do every step to release a new version of a library hosted on GitHub and published on npm

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var prepublish = function () {
  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return (0, _utils.exec)('npm run prepublish', { stdio: stdio });

          case 2:
            _utils.status.doneStep(true);

          case 3:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function prepublish() {
    return _ref.apply(this, arguments);
  };
}();

var generatePackage = function () {
  var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return (0, _utils.exec)('npm pack', { stdio: stdio });

          case 2:
            _utils.status.doneStep(true);

          case 3:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  return function generatePackage() {
    return _ref2.apply(this, arguments);
  };
}();

var confirmation = function () {
  var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(tarPackageFilePath) {
    var tarContents;
    return _regenerator2.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            // log package
            (0, _utils.info)('Package contents');
            _context3.next = 3;
            return readTar(tarPackageFilePath);

          case 3:
            tarContents = _context3.sent;

            tarContents.forEach(function (f) {
              return (0, _utils.log)('  ' + f.replace('package/', ''));
            });
            (0, _utils.emptyLine)();

            _context3.next = 8;
            return _utils.rl.confirmation('If you continue you will publish the package on npm. Are you sure?');

          case 8:
            if (_context3.sent) {
              _context3.next = 11;
              break;
            }

            deletePackage(tarPackageFilePath);
            throw new _utils.SmoothReleaseError('You refused the generated package. Aborting');

          case 11:
            (0, _utils.emptyLine)();

          case 12:
          case 'end':
            return _context3.stop();
        }
      }
    }, _callee3, this);
  }));

  return function confirmation(_x) {
    return _ref3.apply(this, arguments);
  };
}();

var publish = function () {
  var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(useTarPackage, tarPackageFilename, tarPackageFilePath) {
    return _regenerator2.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _utils.status.addSteps(['Run "npm publish"']);

            if (!useTarPackage) {
              _context4.next = 6;
              break;
            }

            _context4.next = 4;
            return (0, _utils.exec)('npm publish ' + tarPackageFilename + ' --registry https://registry.npmjs.org/', { stdio: stdio });

          case 4:
            _context4.next = 8;
            break;

          case 6:
            _context4.next = 8;
            return (0, _utils.exec)('npm publish --registry https://registry.npmjs.org/', { stdio: stdio });

          case 8:

            deletePackage(tarPackageFilePath);
            _utils.status.doneStep(true);

          case 10:
          case 'end':
            return _context4.stop();
        }
      }
    }, _callee4, this);
  }));

  return function publish(_x2, _x3, _x4) {
    return _ref4.apply(this, arguments);
  };
}();

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _tar = require('tar');

var _tar2 = _interopRequireDefault(_tar);

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

var _config = require('../config');

var _config2 = _interopRequireDefault(_config);

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

var stdio = [process.stdin, null, process.stderr];

var readTar = function readTar(file) {
  var actual = [];
  var onentry = function onentry(entry) {
    return actual.push(entry.path);
  };
  return _tar2.default.list({ file: file, onentry: onentry }).then(function () {
    return actual;
  });
};

function deletePackage(tarPackageFilePath) {
  _fs2.default.unlinkSync(tarPackageFilePath);
}

exports.default = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5() {
  var packageJsonName, cleanedPackageJsonName, tarPackageFilename, tarPackageFilePath;
  return _regenerator2.default.wrap(function _callee5$(_context5) {
    while (1) {
      switch (_context5.prev = _context5.next) {
        case 0:
          (0, _utils.title)('Publish package on npm');

          packageJsonName = (0, _utils.getPackageJsonName)();
          cleanedPackageJsonName = packageJsonName.startsWith('@') ? packageJsonName.replace('@', '').replace('/', '-') : packageJsonName;
          tarPackageFilename = cleanedPackageJsonName + '-' + (0, _utils.getPackageJsonVersion)() + '.tgz';
          tarPackageFilePath = _path2.default.resolve((0, _utils.getRootFolderPath)(), tarPackageFilename);

          if (!_config2.default.publish.tarPackageConfirmation) {
            _context5.next = 15;
            break;
          }

          _utils.status.addSteps([(0, _utils.getPackageJsonScripts)().prepublish && 'Run "npm prepublish"', 'Run "npm pack"']);

          _context5.t0 = (0, _utils.getPackageJsonScripts)().prepublish;

          if (!_context5.t0) {
            _context5.next = 11;
            break;
          }

          _context5.next = 11;
          return prepublish();

        case 11:
          _context5.next = 13;
          return generatePackage();

        case 13:
          _context5.next = 15;
          return confirmation(tarPackageFilePath);

        case 15:
          _context5.next = 17;
          return publish(_config2.default.publish.tarPackageConfirmation, tarPackageFilename, tarPackageFilePath);

        case 17:
        case 'end':
          return _context5.stop();
      }
    }
  }, _callee5, undefined);
}));