@reactivehub/cli/dist/core/deploy.js

Event Cli Tols

'use strict';

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

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _api = require('../services/api');

var _auth = require('./auth');

var _auth2 = _interopRequireDefault(_auth);

var _actions = require('../actions');

var _actions2 = _interopRequireDefault(_actions);

var _check = require('./eventCheck/check');

var check = _interopRequireWildcard(_check);

var _checkDeploy = require('../messages/checkDeploy');

var _checkDeploy2 = _interopRequireDefault(_checkDeploy);

var _listener = require('../core/listener');

var _listener2 = _interopRequireDefault(_listener);

var _queries = require('./queries');

var _queries2 = _interopRequireDefault(_queries);

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

var _config2 = _interopRequireDefault(_config);

var _yaml = require('./yaml');

var _yaml2 = _interopRequireDefault(_yaml);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

const loadEvent = id => _yaml2.default.toJson(_config2.default.folders.events(), id);
const getEventsInFolder = () => _yaml2.default.filesInFolder(_config2.default.folders.events()).map(item => item.replace('.yaml', ''));

const namespace = _auth2.default.getNamespace();
const actionErrors = [];

const deployAction = (() => {
  var _ref = (0, _asyncToGenerator3.default)(function* (eventId, filterId, action) {
    const payload = {
      eventId,
      ruleId: filterId,
      namespace
    };

    const { type, action: actionType, operation, id } = action;
    const map = _actions2.default.getActionConfig(type, actionType);
    if (!map) return false;

    let actionDeploy = map.deploy;
    if (operation) {
      const { actions: actionMap = [] } = map;
      const { deploy: operationDeploy } = actionMap.filter(function (actionMapItem) {
        return actionMapItem.name === operation;
      }).shift() || {};
      if (operationDeploy) actionDeploy = operationDeploy;
    }

    if (!actionDeploy) {
      actionErrors.push({ eventId, filterId, message: `Could not deploy action ${id}, invalid action config, check the documentation.` });
      return false;
    }

    const deployStatus = yield actionDeploy(action, payload);
    return deployStatus;
  });

  return function deployAction(_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
})();

const deployFilter = (() => {
  var _ref2 = (0, _asyncToGenerator3.default)(function* (eventId, filter) {
    const { id, name, condition, actions = [] } = filter;
    const payload = {
      id,
      eventId,
      name,
      condition,
      namespace
    };
    yield (0, _api.sendEventFilter)(payload);
    const actionPromises = actions && actions.map(function (action) {
      return deployAction(eventId, id, action).catch(function (err) {
        console.error(err);
        return false;
      });
    });
    if (actionPromises) yield _promise2.default.all(actionPromises);
    return true;
  });

  return function deployFilter(_x4, _x5) {
    return _ref2.apply(this, arguments);
  };
})();

const deployEvent = (() => {
  var _ref3 = (0, _asyncToGenerator3.default)(function* (eventName, { withMessage = true } = {}) {
    const { id: eventId, eventGroup, version, model, filters } = loadEvent(eventName);
    const payload = {
      eventId,
      name: eventId,
      eventGroup,
      version,
      model,
      team: namespace,
      namespace
    };

    yield (0, _api.sendEvent)(payload).then(function () {
      return withMessage && _checkDeploy2.default.eventDeploySuccess(`${eventId}`);
    });

    const filterPromises = filters.map(function (filter) {
      return deployFilter(eventId, filter, { withMessage });
    });

    yield _promise2.default.all(filterPromises);
  });

  return function deployEvent(_x6) {
    return _ref3.apply(this, arguments);
  };
})();

const deployEvents = (() => {
  var _ref4 = (0, _asyncToGenerator3.default)(function* () {
    const testStatus = yield check.run({ isDeploy: true });
    if (testStatus) {
      _checkDeploy2.default.startingDeploy('EVENTS');
      const events = getEventsInFolder();
      const deployPromises = events.map(function (eventModel) {
        return deployEvent(eventModel);
      });
      yield _promise2.default.all(deployPromises);
      _checkDeploy2.default.deployFinished(events.length);
      (0, _api.sendDeploy)({ command: 'deploy:event' });
      return true;
    }
    return false;
  });

  return function deployEvents() {
    return _ref4.apply(this, arguments);
  };
})();

const deployListener = (() => {
  var _ref5 = (0, _asyncToGenerator3.default)(function* () {
    _checkDeploy2.default.startingDeploy('LISTENERS');
    const fileMap = _listener2.default.getListenersFileMaps();
    const deployActions = [];
    fileMap.forEach(function ({ dir, files }) {
      return files.forEach(function (file) {
        return deployActions.push(_listener2.default.prepareDeploy(dir, file, namespace));
      });
    });
    const deployStatus = deployActions.map((() => {
      var _ref6 = (0, _asyncToGenerator3.default)(function* ({ newListener, newListenerTrigger }) {
        const { serviceAccountId, listener } = newListener;
        yield (0, _api.sendListener)((0, _extends3.default)({ namespace }, newListener));
        yield _promise2.default.all(newListenerTrigger.map(function (trigger) {
          return (0, _api.sendListenerTrigger)((0, _extends3.default)({}, trigger, { namespace }));
        }));
        _checkDeploy2.default.listenerDeploySuccess(`${serviceAccountId}.${listener}`);
      });

      return function (_x7) {
        return _ref6.apply(this, arguments);
      };
    })());
    yield _promise2.default.all(deployStatus);
    (0, _api.sendDeploy)({ command: 'deploy:listener' });
    _checkDeploy2.default.deployFinished(deployActions.length, 'listeners');
  });

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

const deployQuery = (() => {
  var _ref7 = (0, _asyncToGenerator3.default)(function* () {
    try {
      _checkDeploy2.default.startingDeploy('QUERIES');
      const fileMap = _queries2.default.getFileMap();
      const deployActions = [];
      fileMap.forEach(function ({ dir, files }) {
        return files.forEach(function (file) {
          return deployActions.push(_queries2.default.prepareDeploy(dir, file, namespace));
        });
      });
      const deployStatus = deployActions.map((() => {
        var _ref8 = (0, _asyncToGenerator3.default)(function* (item) {
          return (0, _api.sendQuery)(item).then(function () {
            return _checkDeploy2.default.eventDeploySuccess(item.id, 'Query');
          });
        });

        return function (_x8) {
          return _ref8.apply(this, arguments);
        };
      })());
      yield _promise2.default.all(deployStatus);
      (0, _api.sendDeploy)({ command: 'deploy:query' });
      _checkDeploy2.default.deployFinished(deployActions.length, 'queries');
    } catch (e) {
      _checkDeploy2.default.queryErrors();
    }
  });

  return function deployQuery() {
    return _ref7.apply(this, arguments);
  };
})();

const deployAll = (() => {
  var _ref9 = (0, _asyncToGenerator3.default)(function* () {
    (0, _api.sendDeploy)({ command: 'deploy:all' });
    yield deployEvents();
    yield deployListener();
    yield deployQuery();
  });

  return function deployAll() {
    return _ref9.apply(this, arguments);
  };
})();

exports.default = {
  deployAll,
  deployListener,
  deployEvents,
  deployQuery,
  deployEvent
};
//# sourceMappingURL=deploy.js.map