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

Global Storage is a Global Distributed Data Warehouse

'use strict';

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

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

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

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

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

var _require3 = require('./utils'),
    typeToPlural = _require3.typeToPlural,
    getEntityPath = _require3.getEntityPath,
    getReferenceType = _require3.getReferenceType,
    getCategoryType = _require3.getCategoryType,
    REFERENCE_TYPES = _require3.REFERENCE_TYPES,
    HIERARCHICAL_RELATIONS = _require3.HIERARCHICAL_RELATIONS;

var preprocessCategoryData = function preprocessCategoryData(entity) {
  var _entity$name$split = entity.name.split('.'),
      _entity$name$split2 = _slicedToArray(_entity$name$split, 2),
      first = _entity$name$split2[0],
      second = _entity$name$split2[1];

  if (!second) {
    entity.category = entity.module;
  } else {
    entity.category = first;
    entity.name = second;
  }

  return [];
};

var addCategoryData = function addCategoryData(type, entity, ms) {
  var errors = [];
  var prop = typeToPlural(type);
  var category = ms.categories.get(entity.category);
  entity.resources = new Map();

  if (!entity.category) {
    errors.push(new SchemaValidationError('unlinked', getEntityPath(entity), {
      type: type
    }));
  } else if (!category) {
    errors.push(new SchemaValidationError('unresolved', getEntityPath(entity), {
      type: 'category',
      value: entity.category
    }));
  } else if (category[prop].has(entity.name)) {
    errors.push(new SchemaValidationError('duplicate', entity.category, {
      type: type,
      value: entity.name
    }));
  } else {
    category[prop].set(entity.name, entity);
  }

  return errors;
};

var checkDetail = function checkDetail(category, master) {
  return ['Catalog', 'Subsystem', 'Hierarchy'].filter(function (type) {
    return category[type.toLowerCase()];
  }).map(function (type) {
    return new SchemaValidationError('detailHierarchy', category.name, {
      type: type,
      master: master.name
    });
  });
};

var addCategory = function addCategory(category) {
  category.actions = new Map();
  category.forms = new Map();
  category.resources = new Map();
  category.references = iter(REFERENCE_TYPES).reduce(function (references, type) {
    references[type] = [];
    return references;
  }, {});
  var errors = [];
  Object.entries(category.definition).forEach(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        key = _ref2[0],
        value = _ref2[1];

    var decorator = extractDecorator(value);

    if (decorator === 'Hierarchy' && !value.category) {
      value.category = category.name;
    }

    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = HIERARCHICAL_RELATIONS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var decor = _step.value;

        if (decorator === decor) {
          var property = decorator.toLowerCase();

          if (category[property]) {
            errors.push(new SchemaValidationError('duplicate', "".concat(category.name, ".").concat(key), {
              type: 'hierarchical relation',
              value: decor
            }));
          } else {
            category[property] = key;
          }
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  });
  return errors;
}; // Verifies that there could be link from source category to destination
//   source - <Object>
//   destination - <Object>
//   propertyName - <string>
// Returns: <SchemaValidationError> | <null> information about error or null
//   if link is valid


var verifyLink = function verifyLink(source, destination, propertyName) {
  var sourceType = getCategoryType(source.definition);
  var destinationType = getCategoryType(destination.definition);

  if (destinationType === 'Log' || destinationType === 'Local' && sourceType !== 'Local') {
    return new SchemaValidationError('illegalLink', "".concat(source.name, ".").concat(propertyName), {
      sourceType: sourceType,
      destination: destination.name,
      destinationType: destinationType
    });
  }

  return null;
};

var processRelations = function processRelations(category, ms) {
  var errors = [];

  var _arr2 = Object.entries(category.definition);

  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
    var _arr2$_i = _slicedToArray(_arr2[_i2], 2),
        fieldName = _arr2$_i[0],
        field = _arr2$_i[1];

    if (!field.category) {
      continue;
    }

    var destination = ms.categories.get(field.category);

    if (!destination) {
      continue;
    }

    var error = verifyLink(category, destination, fieldName);

    if (error) {
      errors.push(error);
      continue;
    }

    var decorator = extractDecorator(field);
    var type = getReferenceType(decorator);

    if (type === 'Include') {
      errors.push.apply(errors, _toConsumableArray(checkDetail(destination, category)));
    } else if (type === 'Master') {
      errors.push.apply(errors, _toConsumableArray(checkDetail(category, destination)));
    }

    destination.references[type].push({
      category: category.name,
      property: fieldName
    });
  }

  return errors;
};

var validateCategory = function validateCategory(ms, category, instance, options) {
  return validate(ms, category.definition, instance, options);
};

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

  var errors = [];

  var _arr3 = Object.entries(instance);

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

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

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

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

        continue;
      }

      if (def.category) {
        if (extractDecorator(def) === 'Include') {
          result[key] = ms.create('category', def, value);
        }
      }
    } catch (err) {
      errors.push(err);
    }
  }

  return [errors, result];
};

module.exports = {
  preprocessCategoryData: preprocessCategoryData,
  addCategory: addCategory,
  addCategoryData: addCategoryData,
  processRelations: processRelations,
  validateCategory: validateCategory,
  categoryCreator: categoryCreator
};