zapier-platform-cli/lib/utils/misc.js

The CLI for apps in the Zapier Developer Platform.

'use strict';

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var cp = require('child_process');

var _ = require('lodash');
var colors = require('colors/safe');
var path = require('path');
var fse = require('fs-extra');
var os = require('os');

var _require = require('../constants'),
    PLATFORM_PACKAGE = _require.PLATFORM_PACKAGE;

var camelCase = function camelCase(str) {
  return _.capitalize(_.camelCase(str));
};
var snakeCase = function snakeCase(str) {
  return _.snakeCase(str);
};

var isWindows = function isWindows() {
  return os.platform().match(/^win/i);
};

// Run a bash command with a promise.
var runCommand = function runCommand(command, args, options) {
  if (isWindows()) {
    command += '.cmd';
  }

  options = options || {};
  if (global.argOpts.debug) {
    console.log('\n');
    console.log('Running ' + colors.bold(command + ' ' + args.join(' ')) + ' command in ' + colors.bold(options.cwd || process.cwd()) + ':\n');
  }
  return new Promise(function (resolve, reject) {
    var result = cp.spawn(command, args, options);

    var stdout = '';
    if (result.stdout) {
      result.stdout.on('data', function (data) {
        stdout += data.toString();
        if (global.argOpts.debug) {
          console.log(colors.green(stdout));
        }
      });
    }

    var stderr = '';
    if (result.stderr) {
      result.stderr.on('data', function (data) {
        stderr += data.toString();
        if (global.argOpts.debug) {
          console.log(colors.red(stdout));
        }
      });
    }

    result.on('error', reject);

    result.on('close', function (code) {
      if (code !== 0) {
        reject(new Error(stderr));
      }
      resolve(stdout);
    });
  });
};

var parseVersions = function parseVersions(versionString) {
  return versionString.split('.').map(function (s) {
    return parseInt(s, 10);
  });
};

var readNvmVersion = function readNvmVersion() {
  var nvmrc = path.resolve(__dirname, '../../.nvmrc');
  var nvmVersion = fse.readFileSync(nvmrc, 'utf8').substr(1); // strip off leading 'v'
  return nvmVersion;
};

// verifies that the current node version is >= the version found in .nvmrc
var isValidNodeVersion = function isValidNodeVersion() {
  var nvmVersion = readNvmVersion();

  var _parseVersions = parseVersions(nvmVersion),
      _parseVersions2 = _slicedToArray(_parseVersions, 3),
      nvmMajor = _parseVersions2[0],
      nvmMinor = _parseVersions2[1],
      nvmPatch = _parseVersions2[2];

  var _parseVersions3 = parseVersions(process.versions.node),
      _parseVersions4 = _slicedToArray(_parseVersions3, 3),
      major = _parseVersions4[0],
      minor = _parseVersions4[1],
      patch = _parseVersions4[2];

  return major > nvmMajor || major === nvmMajor && minor > nvmMinor || major === nvmMajor && minor === nvmMinor && patch >= nvmPatch;
};

var isValidAppInstall = function isValidAppInstall(command) {
  if (['help', 'init', 'login', 'apps', 'convert'].includes(command)) {
    return true;
  }

  var packageJson = void 0;
  try {
    packageJson = require(path.join(process.cwd(), 'package.json'));
    var coreVersion = packageJson.dependencies[PLATFORM_PACKAGE];
    // could check for a lot more, but this is probably enough: https://docs.npmjs.com/files/package.json#dependencies
    if (!coreVersion || coreVersion.includes('^')) {
      return false;
    }
  } catch (err) {
    return false;
  }

  // try skipping the CLI itself
  var CLIpackageJson = require(path.join(__dirname, '../../package.json'));
  if (_.isEqual(packageJson, CLIpackageJson)) {
    return true;
  }

  var dependencies = packageJson.dependencies || {};
  if (!dependencies[PLATFORM_PACKAGE]) {
    return false;
  }

  try {
    require(process.cwd() + '/node_modules/' + PLATFORM_PACKAGE);
  } catch (err) {
    return false;
  }

  return true;
};

var npmInstall = function npmInstall(appDir) {
  return runCommand('npm', ['install'], { cwd: appDir });
};

/*
  Promise do-while loop. Executes promise returned by action,
  passing result to stop function. Keeps running action until
  stop returns falsey. Action is always run at least once.
 */
var promiseDoWhile = function promiseDoWhile(action, stop) {
  var loop = function loop() {
    return action().then(function (result) {
      return stop(result) ? result : loop();
    });
  };
  return loop();
};

/* Delay a promise, by just a bit. */
var promiseDelay = function promiseDelay() {
  var delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;

  return function () {
    return new Promise(function (resolve) {
      setTimeout(function () {
        return resolve();
      }, delay);
    });
  };
};

/* Never stop looping. */
var promiseForever = function promiseForever(action) {
  var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;

  var loop = function loop() {
    return action().then(promiseDelay(delay)).then(loop);
  };
  return loop();
};

/* Return full path to entry point file as specified in package.json (ie "index.js") */
var entryPoint = function entryPoint(dir) {
  dir = dir || process.cwd();
  var packageJson = require(path.resolve(dir, 'package.json'));
  return fse.realpathSync(path.resolve(dir, packageJson.main));
};

module.exports = {
  camelCase: camelCase,
  entryPoint: entryPoint,
  isValidAppInstall: isValidAppInstall,
  isValidNodeVersion: isValidNodeVersion,
  isWindows: isWindows,
  npmInstall: npmInstall,
  promiseDoWhile: promiseDoWhile,
  promiseForever: promiseForever,
  readNvmVersion: readNvmVersion,
  runCommand: runCommand,
  snakeCase: snakeCase
};