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

Event Cli Tols

'use strict';

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

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

var _promise2 = _interopRequireDefault(_promise);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _event = require('./event');

var _event2 = _interopRequireDefault(_event);

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);

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, getEventsInFolder } = _event2.default;
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;
      });
    });
    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) {
    const { id: eventId, eventGroup, name, version, model, filters } = loadEvent('events', eventName);
    const payload = {
      eventId,
      name,
      eventGroup,
      version,
      model,
      team: namespace,
      namespace
    };

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

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

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

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

exports.default = (0, _asyncToGenerator3.default)(function* () {
  const testStatus = yield check.run({ isDeploy: true });
  if (testStatus) {
    _checkDeploy2.default.startingDeploy();
    const events = getEventsInFolder();
    const deployPromises = events.map(function (eventModel) {
      return deployEvent(eventModel);
    });
    yield _promise2.default.all(deployPromises);
    _checkDeploy2.default.deployFinished(events.length);
    return true;
  }
  return false;
});
//# sourceMappingURL=deploy.js.map