canner/lib/query/schema/utils.js

Build CMS in few lines of code for different data sources

"use strict";

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

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isCompositeType = exports.capitalizeFirstLetter = exports.createSchema = exports.createField = exports.getType = void 0;

var _mapValues = _interopRequireDefault(require("lodash/mapValues"));

var _types = require("./types");

var _scalarField = _interopRequireDefault(require("./scalarField"));

var _arrayField = _interopRequireDefault(require("./arrayField"));

var _objectField = _interopRequireDefault(require("./objectField"));

var _relationField = _interopRequireDefault(require("./relationField"));

var _compositeField = _interopRequireDefault(require("./compositeField"));

var getType = function getType(type) {
  var upperType = type.toUpperCase();
  var enumType = _types.types[upperType];
  return enumType || null;
};

exports.getType = getType;

var createField = function createField(key, rootSchema, schema, isEntity) {
  var type = getType(schema.type);

  switch (type) {
    case _types.types.ARRAY:
      return new _arrayField.default({
        key: key,
        rootSchema: rootSchema,
        schema: schema,
        isEntity: isEntity
      });

    case _types.types.OBJECT:
      return new _objectField.default({
        key: key,
        rootSchema: rootSchema,
        schema: schema,
        isEntity: isEntity
      });

    case _types.types.RELATION:
      return new _relationField.default({
        key: key,
        rootSchema: rootSchema,
        schema: schema
      });

    /**
     * File {contentType: string, name: string, size: string, url: string}
     * Image {contentType: string, name: string, size: string, url: string}
     */

    case _types.types.FILE:
    case _types.types.IMAGE:
      {
        var childFields = {
          contentType: {
            type: 'string'
          },
          name: {
            type: 'string'
          },
          size: {
            type: 'string'
          },
          url: {
            type: 'string'
          }
        };
        return new _compositeField.default({
          key: key,
          type: type,
          rootSchema: rootSchema,
          childFields: childFields
        });
      }

    /**
     * GeoPoint {lat: , lng: string, placeId: string, address: string}
     */

    case _types.types.GEOPOINT:
      {
        var _childFields = {
          lat: {
            type: 'string'
          },
          lng: {
            type: 'string'
          },
          placeId: {
            type: 'string'
          },
          address: {
            type: 'string'
          }
        };
        return new _compositeField.default({
          key: key,
          type: type,
          rootSchema: rootSchema,
          childFields: _childFields
        });
      }

    default:
      return new _scalarField.default({
        key: key,
        schema: schema,
        type: type
      });
  }
};

exports.createField = createField;

var createSchema = function createSchema(rootSchema) {
  return (0, _mapValues.default)(rootSchema, function (fieldSchema, key) {
    return createField(key, rootSchema, rootSchema[key], true);
  });
};

exports.createSchema = createSchema;

var capitalizeFirstLetter = function capitalizeFirstLetter(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
};

exports.capitalizeFirstLetter = capitalizeFirstLetter;

var isCompositeType = function isCompositeType(type) {
  var enumType = getType(type);
  return [_types.types.FILE, _types.types.GEOPOINT, _types.types.IMAGE].indexOf(enumType) >= 0;
};

exports.isCompositeType = isCompositeType;