globalstorage/dist/lib/metaschema-config/resource.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; }

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

var _require2 = require('./utils'),
    typeToPlural = _require2.typeToPlural;

var preprocessResources = function preprocessResources(resources) {
  var parts = resources.name.split('.');

  if (parts.length === 1) {
    resources.locale = parts[0];
    resources.category = resources.module;
  } else if (parts.length === 2) {
    var _parts = _slicedToArray(parts, 2);

    resources.category = _parts[0];
    resources.locale = _parts[1];
  } else if (parts.length === 3) {
    var _parts2 = _slicedToArray(parts, 3);

    resources.entityName = _parts2[0];
    resources.entityType = _parts2[1];
    resources.locale = _parts2[2];
  } else {
    var _parts3 = _slicedToArray(parts, 4);

    resources.category = _parts3[0];
    resources.entityName = _parts3[1];
    resources.entityType = _parts3[2];
    resources.locale = _parts3[3];
  }

  return [];
};

var addResources = function addResources(_ref, ms) {
  var name = _ref.name,
      locale = _ref.locale,
      category = _ref.category,
      definition = _ref.definition,
      entityName = _ref.entityName,
      entityType = _ref.entityType;

  if (category === 'common') {
    if (ms.resources.common.has(locale)) {
      return [new SchemaValidationError('duplicate', name, {
        type: 'resources',
        value: locale
      })];
    }

    ms.resources.common.set(locale, JSON.stringify(definition));
  } else if (category === 'domains') {
    var location = ms.resources.domains;

    if (!location.has(locale)) {
      location.set(locale, JSON.stringify(definition));
    } else {
      var errors = [];
      var obj = JSON.parse(location.get(locale));

      var _arr2 = Object.entries(definition);

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

        if (obj[key]) {
          errors.push(new SchemaValidationError('duplicate', name, {
            type: 'domain localization',
            value: key
          }));
        } else {
          obj[key] = localization;
        }
      }

      location.set(locale, JSON.stringify(obj));
      return errors;
    }
  } else {
    var cat = ms.categories.get(category);

    var _location;

    if (!entityType) {
      _location = cat;
    } else if (entityType === 'action' && ms.actions.has(entityName)) {
      _location = ms.actions.get(entityName);
    } else if (cat) {
      _location = cat[typeToPlural(entityType)].get(entityName);
    }

    if (!_location) {
      return [new SchemaValidationError('unresolved', name, {
        type: entityType || 'category',
        value: entityName || category
      })];
    }

    if (_location.resources.has(locale)) {
      return [new SchemaValidationError('duplicate', name, {
        type: 'resources',
        value: locale
      })];
    }

    _location.resources.set(locale, JSON.stringify(definition));
  }

  return [];
};

module.exports = {
  preprocessResources: preprocessResources,
  addResources: addResources
};