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

Event Cli Tols

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.checkAll = exports.checkEvent = undefined;

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

var _promise2 = _interopRequireDefault(_promise);

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

var _extends3 = _interopRequireDefault(_extends2);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _event2 = _interopRequireDefault(_event);

var _query = require('../libs/query');

var _query2 = _interopRequireDefault(_query);

var _objects = require('../libs/objects');

var _objects2 = _interopRequireDefault(_objects);

var _serviceAccounts = require('../serviceAccounts');

var _serviceAccounts2 = _interopRequireDefault(_serviceAccounts);

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

const checkAction = (() => {
  var _ref = (0, _asyncToGenerator3.default)(function* ({ action, filter }) {
    const { id, type, serviceAccountId } = action;
    const prefix = `Action: ${filter}:${id} `;
    const required = _objects2.default.checkRequired(action, ['id', 'type', 'action', 'serviceAccountId'], prefix);
    let status = true;
    let messages = [];

    if (!required.status) {
      status = false;
      messages = messages.concat(required.messages);
    }

    const checkServiceAccount = yield _serviceAccounts2.default.isServiceAccountOfType({ type, id: serviceAccountId });
    if (!checkServiceAccount) {
      status = false;
      messages.push(`Service Account ${serviceAccountId} is not of action type ${type}`);
    }

    return { status, action: id, messages };
  });

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

const checkConditionFilter = ({ id, condition }) => {
  if (!condition) return { status: true, messages: [] };
  return (0, _extends3.default)({ filter: id }, _query2.default.checkQuery(condition));
};

const checkFilters = (() => {
  var _ref2 = (0, _asyncToGenerator3.default)(function* (filter) {
    const { id, condition, actions = [] } = filter;
    const checkCondition = checkConditionFilter({ id, condition });
    let { status } = checkCondition;

    const actionErrors = yield _promise2.default.all(actions.map(function (action) {
      return checkAction({ filter: id, action });
    })).then(function (actionVerify) {
      return actionVerify.filter(function ({ status: verifyStatus }) {
        return !verifyStatus;
      });
    });

    if (actionErrors.length > 0) status = false;

    let errors = [];
    if (!checkCondition.status) errors.push(checkCondition);
    if (actionErrors.length > 0) errors = errors.concat(actionErrors);

    const requiredFields = _objects2.default.checkRequired(filter, ['id'], 'Filters:');
    if (!requiredFields.status) {
      status = false;
      errors.push((0, _extends3.default)({ filter: id }, requiredFields));
    }
    return { id, status, errors };
  });

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

const checkModel = (id, model) => (0, _extends3.default)({ id }, _query2.default.checkPropertyTypes(model));

const checkEvent = exports.checkEvent = (() => {
  var _ref3 = (0, _asyncToGenerator3.default)(function* (id) {
    const eventPayload = _event2.default.loadEventData(id);
    const { model = {}, filters = [] } = eventPayload;

    const requiredVerify = _objects2.default.checkRequired(eventPayload, ['id', 'model', 'filters']);
    const modelVerify = checkModel(id, model);
    let { status } = requiredVerify;

    const { status: modelStatus } = modelVerify;
    if (!modelStatus) status = modelStatus;

    const filterErrors = filters && (yield _promise2.default.all(filters.map(function (filter) {
      return checkFilters(filter);
    })).then(function (verify) {
      return verify.filter(function ({ status: verifyStatus }) {
        return !verifyStatus;
      });
    })) || [];

    let errors = [];
    if (!requiredVerify.status) errors = errors.concat(requiredVerify);
    if (!modelVerify.status) errors = errors.concat(modelVerify);
    if (filterErrors.length > 0) {
      filterErrors.forEach(function (error) {
        errors = errors.concat(error.errors);
      });
      status = false;
    }

    return { id, status, errors };
  });

  return function checkEvent(_x3) {
    return _ref3.apply(this, arguments);
  };
})();

const checkAll = exports.checkAll = (() => {
  var _ref4 = (0, _asyncToGenerator3.default)(function* () {
    const events = _event2.default.getEventsInFolder();
    const eventsWithErrors = yield _promise2.default.all(events.map(function (item) {
      return checkEvent(item);
    })).then(function (verify) {
      return verify.filter(function ({ status: verifyStatus }) {
        return !verifyStatus;
      });
    });
    console.log(eventsWithErrors[0].errors[0]);
    return { status: eventsWithErrors.length === 0, errors: eventsWithErrors };
  });

  return function checkAll() {
    return _ref4.apply(this, arguments);
  };
})();
//# sourceMappingURL=checkDeploy.js.map