canner-compiler/lib/parser.js

Compiler for Canner CMS schema

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var Parser =
/*#__PURE__*/
function () {
  function Parser() {
    (0, _classCallCheck2.default)(this, Parser);
    (0, _defineProperty2.default)(this, "ast", void 0);
    this.ast = {};
  }

  (0, _createClass2.default)(Parser, [{
    key: "parse",
    value: function parse(schema) {
      var _this = this;

      Object.keys(schema).forEach(function (key) {
        var entitySchema = schema[key];

        if (entitySchema.type === 'array') {
          _this.ast[key] = _this.parseArray(key, entitySchema, {
            pattern: 'array',
            path: key
          });
        } else if (entitySchema.type === 'object') {
          _this.ast[key] = _this.parseObject(key, entitySchema, {
            pattern: 'object',
            path: key
          });
        } else if (entitySchema.type === 'page') {
          _this.ast[key] = _this.parsePage(key, entitySchema, {
            pattern: 'page',
            path: key
          });
        } else {
          throw new Error('Entity schema type shoule be one of ["object", "array", "page"]');
        }
      });
      return this.ast;
    }
  }, {
    key: "parseObject",
    value: function parseObject(key, schema, state) {
      var _this2 = this;

      var children = {};

      if (schema.type !== 'object') {
        throw new Error("".concat(key, " is not a object schema"));
      }

      children = schema.items || {};
      var ui = schema.ui || getDefaultUI(schema.type);
      return (0, _objectSpread2.default)({}, schema, {
        name: key,
        nodeType: generateNodeType(schema),
        children: Object.keys(children).map(function (key) {
          return _this2.parsePlugin(key, children[key], state);
        }),
        pattern: state.pattern,
        path: state.path,
        ui: ui
      });
    }
  }, {
    key: "parseJson",
    value: function parseJson(key, schema, state) {
      var _this3 = this;

      var children = {};

      if (schema.type !== 'json') {
        throw new Error("".concat(key, " is not a json schema"));
      }

      children = schema.items || {};
      var ui = schema.ui || getDefaultUI(schema.type);
      return (0, _objectSpread2.default)({}, schema, {
        name: key,
        nodeType: generateNodeType(schema),
        children: Object.keys(children).map(function (key) {
          return _this3.parsePlugin(key, children[key], state);
        }),
        pattern: state.pattern,
        path: state.path,
        ui: ui
      });
    }
  }, {
    key: "parsePage",
    value: function parsePage(key, schema, state) {
      var _this4 = this;

      var children = {};

      if (schema.type !== 'page') {
        throw new Error("".concat(key, " is not a page schema"));
      }

      children = schema.items || {};
      var ui = schema.ui || getDefaultUI(schema.type);
      return (0, _objectSpread2.default)({}, schema, {
        name: key,
        nodeType: generateNodeType(schema),
        children: Object.keys(children).map(function (key) {
          return _this4.parsePlugin(key, children[key], state);
        }),
        pattern: state.pattern,
        path: state.path,
        ui: ui
      });
    }
  }, {
    key: "parseArray",
    value: function parseArray(key, schema, state) {
      var _this5 = this;

      if (schema.type !== 'array') {
        throw new Error("".concat(key, " is not a object schema"));
      }

      if (schema.items) {
        var children = schema.items.items || {};
        var ui = schema.ui || getDefaultUI(schema.type);
        return (0, _objectSpread2.default)({}, schema, {
          name: key,
          nodeType: generateNodeType(schema),
          children: Object.keys(children).map(function (key) {
            return _this5.parsePlugin(key, children[key], state);
          }),
          pattern: state.pattern,
          path: state.path,
          ui: ui
        });
      }

      return (0, _objectSpread2.default)({}, schema, {
        name: key,
        nodeType: generateNodeType(schema),
        pattern: state.pattern,
        path: state.path
      });
    }
  }, {
    key: "parsePlugin",
    value: function parsePlugin(key, schema, state) {
      var path = state.path,
          pattern = state.pattern;

      if (schema.type === 'object') {
        return this.parseObject(key, schema, {
          pattern: "".concat(pattern, ".object"),
          path: "".concat(path, "/").concat(key)
        });
      }

      if (schema.type === 'json') {
        return this.parseJson(key, schema, {
          pattern: "".concat(pattern, ".json"),
          path: "".concat(path, "/").concat(key)
        });
      }

      if (schema.type === 'array') {
        return this.parseArray(key, schema, {
          pattern: "".concat(pattern, ".array"),
          path: "".concat(path, "/").concat(key)
        });
      }

      var ui = schema.ui || getDefaultUI(schema.type);
      return (0, _objectSpread2.default)({}, schema, {
        name: key,
        nodeType: generateNodeType(schema),
        pattern: "".concat(pattern, ".").concat(schema.type),
        path: "".concat(path, "/").concat(key),
        ui: ui
      });
    }
  }]);
  return Parser;
}();

exports.default = Parser;

function getDefaultUI(type) {
  switch (type) {
    case 'array':
      return 'tab';

    case 'number':
    case 'string':
      return 'input';

    case 'boolean':
      return 'switch';

    case 'object':
      return 'fieldset';

    case 'relation':
      return 'one';

    default:
      return 'default';
  }
}

function generateNodeType(schema) {
  var ui = schema.ui || getDefaultUI(schema.type);
  var nodetype = 'component';

  if (['page', 'component'].indexOf(schema.type) !== -1) {
    nodetype = 'page';
  }

  return "".concat(nodetype, ".").concat(schema.type, ".").concat(ui);
}