globalstorage/dist/lib/metaschema-config/action.js

Global Storage is a Global Distributed Data Warehouse

'use strict';

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

var _require = require('@metarhia/common'),
    iter = _require.iter;

var _require2 = require('metaschema'),
    SchemaValidationError = _require2.errors.SchemaValidationError;

var _require3 = require('./category'),
    addCategoryData = _require3.addCategoryData;

var _require4 = require('./utils'),
    getEntityPath = _require4.getEntityPath,
    processFields = _require4.processFields;

var validate = require('./validate');

var addAction = function addAction(entity, ms) {
  var errors = [];

  if (entity.definition.Public) {
    entity.category = null;
    entity.resources = new Map();

    if (ms.actions.has(entity.name)) {
      errors.push(new SchemaValidationError('duplicate', entity.name, {
        type: 'action'
      }));
    } else {
      ms.actions.set(entity.name, entity);
    }
  } else {
    errors.push.apply(errors, _toConsumableArray(addCategoryData('action', entity, ms)));
  }

  return errors;
};

var processAction = function processAction(action, ms) {
  var errors = [];
  var def = action.definition;
  var category = ms.categories.get(action.category);

  if (!category && !action.definition.Public) {
    return [];
  }

  errors.push.apply(errors, _toConsumableArray(processFields(ms, category && category.definition, def.Args, "".concat(getEntityPath(action), ".Args"))));
  errors.push.apply(errors, _toConsumableArray(processFields(ms, category && category.definition, def.Returns, "".concat(getEntityPath(action), ".Returns"))));
  var formName = def.Form || action.name;
  var form = category && category.forms.get(formName);

  if (form) {
    form.usedIn.push(action.name);
    iter(Object.keys(def.Args)).filter(function (arg) {
      return !!form.definition.Fields[arg];
    }).each(function (arg) {
      return errors.push(new SchemaValidationError('duplicate', "".concat(getEntityPath(action), ".Args"), {
        type: 'property',
        value: arg
      }));
    });
    action.form = form.definition;
  }

  return errors;
};

var validateAction = function validateAction(ms, action, instance, options) {
  return validate(ms, action.definition.Args, instance, options);
};

var actionCreator = function actionCreator(ms, schema, instance) {
  var result = _objectSpread({}, instance);

  var errors = [];

  var _arr = Object.entries(instance);

  for (var _i = 0; _i < _arr.length; _i++) {
    var _arr$_i = _slicedToArray(_arr[_i], 2),
        key = _arr$_i[0],
        value = _arr$_i[1];

    var def = schema.definition.Args[key];
    if (!def) continue;

    try {
      if (def.domain) {
        var definition = def.definition;

        if (typeof definition.parse === 'function') {
          result[key] = definition.parse(value);
        }
      }
    } catch (err) {
      errors.push(err);
    }
  }

  return [errors, result];
};

module.exports = {
  processAction: processAction,
  addAction: addAction,
  validateAction: validateAction,
  actionCreator: actionCreator
};