zapier-platform-cli/lib/utils/local.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 _ = require('lodash');
var colors = require('colors');
var path = require('path');

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

var _require2 = require('./display'),
    prettyJSONstringify = _require2.prettyJSONstringify;

var _require3 = require('./promisify'),
    promisify = _require3.promisify;

var nodeWatch = function nodeWatch() {
  return require('node-watch').apply(undefined, arguments);
};
var makeTunnelUrl = function makeTunnelUrl() {
  return promisify(require('ngrok').connect).apply(undefined, arguments);
};

var getLocalAppHandler = function getLocalAppHandler() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      _ref$reload = _ref.reload,
      reload = _ref$reload === undefined ? false : _ref$reload,
      _ref$baseEvent = _ref.baseEvent,
      baseEvent = _ref$baseEvent === undefined ? {} : _ref$baseEvent;

  var entryPath = process.cwd() + '/index';
  var rootPath = path.dirname(require.resolve(entryPath));
  if (reload) {
    Object.keys(require.cache).map(function (cachePath) {
      if (cachePath.startsWith(rootPath)) {
        delete require.cache[cachePath];
      }
    });
  }
  var appRaw = void 0,
      zapier = void 0;
  try {
    appRaw = require(entryPath);
    zapier = require(rootPath + '/node_modules/' + PLATFORM_PACKAGE);
  } catch (err) {
    // this err.stack doesn't give a nice traceback at all :-(
    // maybe we could do require('syntax-error') in the future
    return function (event, ctx, callback) {
      return callback(err);
    };
  }
  var handler = zapier.createAppHandler(appRaw);
  return function (event, ctx, callback) {
    event = _.merge({}, event, {
      calledFromCli: true
    }, baseEvent);
    handler(event, _, callback);
  };
};

// Runs a local app command (./index.js) like {command: 'validate'};
var localAppCommand = function localAppCommand(event) {
  var handler = getLocalAppHandler();
  return new Promise(function (resolve, reject) {
    handler(event, {}, function (err, resp) {
      if (err) {
        reject(err);
      } else {
        resolve(resp.results);
      }
    });
  });
};

// translate a JS Error into what would be returned from lambda
var createAWSError = function createAWSError(error) {
  var stackTrace = error.stack.split(/\n\s+at\s/).slice(1);

  return {
    errorMessage: error.message,
    errorType: error.name,
    stackTrace: stackTrace
  };
};

// Stands up a local tunnel server for app commands.
var localAppTunnelServer = function localAppTunnelServer(options) {
  var jayson = require('jayson');

  var server = jayson.server({
    test: function test(args, callback) {
      callback(null, { 'results': 'Success!' });
    },
    invoke: function invoke(args, callback) {
      var _args = _slicedToArray(args, 1),
          event = _args[0];

      options.log();
      options.log(colors.green('==Method'));
      options.log(event.method);
      options.log(colors.green('==Bundle'));
      options.log(prettyJSONstringify(event.bundle));
      options.handler(event, {}, function (err, resp) {
        if (err) {
          options.log(colors.red(colors.bold('==Error')));
          options.log(err.stack);
          options.log();
        } else {
          options.log(colors.red(colors.bold('==Results')));
          options.log(prettyJSONstringify(resp.results));
          options.log();
        }
        if (err) {
          // match how AWS returns its errors
          var awsError = createAWSError(err);
          callback(null, awsError);
        } else {
          callback(err, resp);
        }
      });
    }
  });

  server.httpServer = server.http();
  server.httpServer.listen(options.port);

  return server;
};

module.exports = {
  getLocalAppHandler: getLocalAppHandler,
  localAppCommand: localAppCommand,
  localAppTunnelServer: localAppTunnelServer,
  makeTunnelUrl: makeTunnelUrl,
  nodeWatch: nodeWatch
};