@actonate/mirkwood
Version:
GraphQL based Rapid Server-side Development framework
433 lines (383 loc) • 13.8 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _graphql = require('graphql');
var _resolver = require('./resolver');
var _resolver2 = _interopRequireDefault(_resolver);
var _types = require('./types');
var _types2 = _interopRequireDefault(_types);
var _errors = require('../errors');
var _lodash = require('lodash');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Meta = function () {
function Meta() {
_classCallCheck(this, Meta);
}
_createClass(Meta, null, [{
key: 'store',
value: function store(typeName, typeSchema) {
var metaFields = [];
var meta = _extends({}, typeSchema);
// flatten all fields
if (typeSchema.fields && _typeof(typeSchema.fields) === 'object') {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = Object.keys(typeSchema.fields)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var key = _step.value;
var field = typeSchema.fields[key];
var fieldType = field.type;
var fieldMeta = null;
// check for object
if (_types2.default.isOfType(fieldType, 'GraphQLObjectType') || _types2.default.isOfType(fieldType, 'GraphQLInputObjectType')) {
fieldMeta = Meta.get(field.type.toString());
}
// Check for Collection (array of objects)
if (_types2.default.isOfType(fieldType, 'GraphQLList') && (_types2.default.isOfType(fieldType.ofType, 'GraphQLObjectType') || _types2.default.isOfType(fieldType.ofType, 'GraphQLInputObjectType'))) {
fieldMeta = Meta.get(fieldType.ofType.toString());
}
var metaField = _extends({}, field, {
// overrides
name: key,
type: fieldType.toString(),
meta: fieldMeta,
array: _types2.default.isOfType(fieldType, 'GraphQLList'),
resolved: field.resolve && typeof field.resolve === 'function' ? true : false
});
if (_types2.default.isOfType(fieldType, 'GraphQLEnumType')) {
metaField.values = (0, _lodash.keys)(this.metaStore[fieldType]);
metaField.keys = (0, _lodash.values)(this.metaStore[fieldType]).map(function (valueObj) {
return valueObj.value;
});
metaField.type = 'Enum';
}
if (fieldType && _types2.default.isOfType(fieldType, 'GraphQLList') && _types2.default.isOfType(fieldType.ofType, 'GraphQLEnumType')) {
metaField.values = (0, _lodash.keys)(this.metaStore[fieldType.ofType]);
metaField.keys = (0, _lodash.values)(this.metaStore[fieldType.ofType]).map(function (valueObj) {
return valueObj.value;
});
metaField.type = '[Enum]';
}
metaFields.push(metaField);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
meta.fields = metaFields;
}
this.metaStore[typeName] = meta;
return true;
}
}, {
key: 'get',
value: function get(typeName) {
typeName = typeName.toString();
if (this.metaStore[typeName]) {
return this.metaStore[typeName];
} else {
return false;
}
}
}, {
key: 'resolveRelationalFields',
value: function resolveRelationalFields(typeMeta, relationKeys) {
var relationFields = (0, _lodash.filter)(typeMeta.fields, function (field) {
return relationKeys.includes(field.name) ? true : false;
});
var resolvedRelationalFieldsMap = {};
relationFields.map(function (relationField) {
var relationName = relationField.name;
var resolvedRelations = [];
// accessing internal type API getFields()
var internalRelationTypeFields = _types2.default.get(relationField.type).getFields();
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = Object.keys(internalRelationTypeFields)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var key = _step2.value;
var field = internalRelationTypeFields[key];
var fieldType = internalRelationTypeFields[key].type;
var baseFieldTypeName = _types2.default.isOfType(fieldType, 'GraphQLList') ? fieldType.ofType.name : fieldType.name;
var nestedRelations = [];
if (relationName === '_child' || relationName === '_children') {
nestedRelations = ['_child', '_children'];
}
if (relationName === '_parent') {
nestedRelations = ['_parent'];
}
resolvedRelations.push({
name: key,
type: fieldType.toString(),
meta: Meta.resolveTypeMeta(Meta.get(baseFieldTypeName), nestedRelations)
});
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
resolvedRelationalFieldsMap[relationField.name] = resolvedRelations;
});
return resolvedRelationalFieldsMap;
}
}, {
key: 'resolveTypeMeta',
value: function resolveTypeMeta(typeMeta) {
var relationKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var filteredKeys = ['_child', '_children', '_parent'];
// handling relations
// Disabled support for relationals till a required usecase comes in the future
// Disabled by Shoaib
// relationKeys = relationKeys ? relationKeys : filteredKeys;
// let relationalFieldsMap = Meta.resolveRelationalFields(typeMeta, relationKeys);
return {
name: typeMeta.name,
fields: (0, _lodash.filter)(typeMeta.fields, function (field) {
return !filteredKeys.includes(field.name) ? true : false;
})
// ...relationalFieldsMap
};
}
}, {
key: 'typeResolver',
value: function typeResolver() {
return new _resolver2.default('meta.type', function (_, args, ctx) {
var typeName = args.name;
var typeMeta = Meta.get(typeName);
if (!typeMeta) {
throw new _errors.TypeNotFoundError({
data: {
name: typeName
}
});
}
return Meta.resolveTypeMeta(typeMeta);
});
}
}, {
key: 'typesResolver',
value: function typesResolver() {
return new _resolver2.default('meta.types', function (_, args, ctx) {
var typesName = args.name;
var typesMeta = [];
typesName.map(function (typeName) {
var typeMeta = Meta.get(typeName);
if (!typeMeta) {
throw new _errors.TypeNotFoundError({
data: {
name: typeName
}
});
}
typesMeta.push(Meta.resolveTypeMeta(typeMeta));
});
return typesMeta;
});
}
}, {
key: 'generateRootMetaType',
value: function generateRootMetaType() {
return _types2.default.generateType({
name: 'RootMeta',
fields: {
type: {
type: Meta.Type,
args: {
name: {
type: _types2.default.String
}
},
resolve: Meta.typeResolver()
},
types: {
type: _types2.default.List(Meta.Type),
args: {
name: {
type: _types2.default.List(_types2.default.String)
}
},
resolve: Meta.typesResolver()
}
}
});
}
}, {
key: 'Type',
get: function get() {
return _types2.default.generateType({
name: 'Meta',
fields: {
name: {
type: _types2.default.String,
required: true
},
fields: {
type: [Meta.FieldType]
},
_child: {
type: [Meta.RelationType]
},
_children: {
type: [Meta.RelationType]
},
_parent: {
type: [Meta.RelationType]
}
}
});
}
}, {
key: 'RelationType',
get: function get() {
return _types2.default.generateType({
name: 'MetaRelation',
fields: function fields() {
return {
name: {
type: _types2.default.String
},
type: {
type: _types2.default.String
},
meta: {
type: Meta.Type
}
};
}
});
}
}, {
key: 'FieldType',
get: function get() {
if (_types2.default.get('MetaFieldType')) {
return _types2.default.get('MetaFieldType');
}
var metaFieldType = new _graphql.GraphQLObjectType({
name: 'MetaField',
fields: function fields() {
return {
name: {
type: _types2.default.String,
required: true
},
type: {
type: _types2.default.String,
required: true
},
meta: { // useful for nested fields that have objects or collections
type: _types2.default.get('MetaType')
},
array: {
type: _types2.default.Boolean
},
resolved: {
type: _types2.default.Boolean
},
description: {
type: _types2.default.String
},
label: {
type: _types2.default.String
},
placeholder: {
type: _types2.default.String
},
query: {
type: _types2.default.String
},
traverse: {
type: _types2.default.String
},
precision: {
type: _types2.default.Int
},
hidden: {
type: _types2.default.Boolean
},
descriptor: {
type: _types2.default.String,
defaultValue: 'text'
},
required: {
type: _types2.default.Boolean
},
min: {
type: _types2.default.Float
},
max: {
type: _types2.default.Float
},
step: {
type: _types2.default.Float
},
len: {
type: _types2.default.Int
},
pattern: {
type: _types2.default.String
},
unique: {
type: _types2.default.Boolean
},
keys: {
type: _types2.default.List(_types2.default.String)
},
values: {
type: _types2.default.List(_types2.default.String)
},
sort: {
type: _types2.default.Boolean
},
filter: {
type: _types2.default.Boolean
},
control: {
type: _types2.default.String
},
icon: {
type: _types2.default.String
},
prefix: {
type: _types2.default.String
},
size: {
type: _types2.default.String
}
};
}
});
_types2.default.store('MetaFieldType', metaFieldType);
return metaFieldType;
}
}]);
return Meta;
}();
Meta.metaStore = {};
exports.default = Meta;