@actonate/mirkwood
Version:
GraphQL based Rapid Server-side Development framework
425 lines (369 loc) • 11.5 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
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 _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 _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 _lodash = require('lodash');
var _meta = require('./meta');
var _meta2 = _interopRequireDefault(_meta);
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 Types = function () {
function Types() {
_classCallCheck(this, Types);
}
_createClass(Types, null, [{
key: 'List',
value: function List(dataType) {
return new _graphql.GraphQLList(dataType);
}
}, {
key: 'Enum',
value: function Enum(name, values) {
if (this.get(name)) {
return this.get(name);
}
var generatedEnum = new _graphql.GraphQLEnumType({
name: name,
values: values
});
this.store(name, generatedEnum);
_meta2.default.store(name, values);
return generatedEnum;
}
}, {
key: 'isOfType',
value: function isOfType(typeCheck, typeName) {
var typeCheckName = typeCheck.constructor.name;
if (typeCheckName === typeName) {
return true;
}
return false;
}
}, {
key: 'isType',
value: function isType(typeCheck) {
var typeName = typeCheck.constructor.name;
var graphQLTypes = ['GraphQLScalarType', 'GraphQLObjectType', 'GraphQLInputObjectType', 'GraphQLList', 'GraphQLEnumType'];
if (graphQLTypes.includes(typeName)) {
return true;
}
}
}, {
key: 'generateArgs',
value: function generateArgs(args, prefix) {
var argsObjects = {};
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = Object.keys(args)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var key = _step.value;
// if already type then get type instance
if (_typeof(args[key].type) === 'object' && args[key].type.fields) {
args[key].type.name = args[key].name || [prefix, key].join('_');
}
argsObjects[key] = _extends({}, args[key], {
type: this.generateInputType(args[key].type)
});
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return argsObjects;
}
}, {
key: 'generateType',
value: function generateType(schema) {
// Check if already Type is being passed
if (this.isType(schema)) {
return schema;
}
// If type already created and referenced
if (typeof schema === 'string') {
return this.get(schema);
}
// if type is specified directly as [{Schema}] or [{TypeName}]
if (Array.isArray(schema)) {
return new _graphql.GraphQLList(this.generateType(schema[0]));
}
var genGraphQLTypeName = [schema.name, 'Type'].join('');
var resolvedModelFields = {};
// check for dupe (already generated)
if (this.get(genGraphQLTypeName)) {
return this.get(genGraphQLTypeName);
}
if (typeof schema.fields === 'function') {
resolvedModelFields = schema.fields; // do nothing
} else {
// flatten all types (resolve complex types recursively)
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = Object.keys(schema.fields)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var fieldKey = _step2.value;
var field = _extends({}, schema.fields[fieldKey]);
var fieldType = Array.isArray(field.type) ? field.type[0] : field.type;
// find complex types
if ((typeof fieldType === 'undefined' ? 'undefined' : _typeof(fieldType)) === 'object' && fieldType.fields) {
fieldType.name = fieldType.name || [schema.name, '_', fieldKey].join('');
fieldType = this.generateType(fieldType);
}
if (Array.isArray(field.type)) {
field.type = new _graphql.GraphQLList(fieldType);
} else {
field.type = fieldType;
}
resolvedModelFields[fieldKey] = field;
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
var graphQLObjectSchema = {
name: genGraphQLTypeName,
fields: resolvedModelFields
};
var genGraphQLType = new _graphql.GraphQLObjectType(graphQLObjectSchema);
// Store in Stores (Type, Meta)
_meta2.default.store(genGraphQLTypeName, graphQLObjectSchema);
this.store(genGraphQLTypeName, genGraphQLType);
return genGraphQLType;
}
}, {
key: 'generateInputType',
value: function generateInputType(schema, filterKeys) {
// Check if already Type is being passed
if (this.isType(schema)) {
return schema;
}
// If type already created and referenced
if (typeof schema === 'string') {
return this.get(schema);
}
// if type is specified directly as [{Schema}] or [{TypeName}]
if (Array.isArray(schema)) {
return new _graphql.GraphQLList(this.generateInputType(schema[0]), filterKeys);
}
var genGraphQLTypeName = [schema.name, 'InputType'].join('');
var resolvedModelFields = {};
// check for dupe (already generated)
if (this.get(genGraphQLTypeName)) {
return this.get(genGraphQLTypeName);
}
// flatten all types (resolve complex types recursively)
if (typeof schema.fields === 'function') {
resolvedModelFields = schema.fields; // do nothing
} else {
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = Object.keys(schema.fields)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var fieldKey = _step3.value;
var field = _extends({}, schema.fields[fieldKey]);
// filter/omit keys if specified
if (Array.isArray(filterKeys) && filterKeys.length > 0) {
field = (0, _lodash.omit)(field, filterKeys);
}
var fieldType = Array.isArray(field.type) ? field.type[0] : field.type;
// skip dynamic fields (that have a resolver)
if (field.resolve) {
continue;
}
// find complex types
if ((typeof fieldType === 'undefined' ? 'undefined' : _typeof(fieldType)) === 'object' && fieldType.fields) {
fieldType.name = fieldType.name || [schema.name, '_', fieldKey].join('');
fieldType = this.generateInputType(fieldType, filterKeys);
}
if (Array.isArray(field.type)) {
field.type = new _graphql.GraphQLList(fieldType);
} else {
field.type = fieldType;
}
resolvedModelFields[fieldKey] = field;
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
var graphQLObjectSchema = {
name: genGraphQLTypeName,
fields: resolvedModelFields
};
var genGraphQLType = new _graphql.GraphQLInputObjectType(graphQLObjectSchema);
// Store in Stores (Type, Meta)
_meta2.default.store(genGraphQLTypeName, graphQLObjectSchema);
this.store(genGraphQLTypeName, genGraphQLType);
return genGraphQLType;
}
}, {
key: 'store',
value: function store(typeName, type) {
this.typeStore[typeName] = type;
return true;
}
}, {
key: 'get',
value: function get(typeName) {
if (this.typeStore[typeName]) {
return this.typeStore[typeName];
} else {
return false;
}
}
}, {
key: 'storeModel',
value: function storeModel(model) {
this.modelStore[model.name] = model;
this.modelStore[model.key] = model;
return true;
}
}, {
key: 'model',
value: function model(modelName) {
if (this.modelStore[modelName]) {
return this.modelStore[modelName];
} else {
return false;
}
}
}, {
key: 'ID',
get: function get() {
return _graphql.GraphQLID;
}
}, {
key: 'Int',
get: function get() {
return _graphql.GraphQLInt;
}
}, {
key: 'Float',
get: function get() {
return _graphql.GraphQLFloat;
}
}, {
key: 'String',
get: function get() {
return _graphql.GraphQLString;
}
}, {
key: 'Boolean',
get: function get() {
return _graphql.GraphQLBoolean;
}
}, {
key: 'OperatorType',
get: function get() {
return this.Enum('Operator', {
'EQUALS': { value: '$eq' },
'NOTEQUALS': { value: '$ne' },
'GREATERTHAN': { value: '$gt' },
'GREATERTHANEQTO': { value: '$gte' },
'LESSTHAN': { value: '$lt' },
'LESSTHANEQTO': { value: '$lte' },
'EXISTS': { value: '$exists' },
'IN': { value: '$in' },
'NOTIN': { value: '$nin' },
'REGEX': { value: '$regex' },
'IREGEX': { value: '$iregex' },
'LIKE': { value: '$like' },
'ILIKE': { value: '$ilike' }
});
}
}, {
key: 'SortType',
get: function get() {
return this.generateInputType({
name: 'SortType',
fields: {
field: {
type: _graphql.GraphQLString
},
order: {
type: _graphql.GraphQLString,
defaultValue: 'asc'
}
}
});
}
}, {
key: 'GroupByType',
get: function get() {
return this.generateInputType({
name: 'GroupByType',
fields: {
field: {
type: _graphql.GraphQLString
}
}
});
}
}, {
key: 'AggregateType',
get: function get() {
return this.generateInputType({
name: 'AggregateType',
fields: {
sum: {
type: [Types.String]
},
count: {
type: [Types.String]
},
avg: {
type: [Types.String]
},
min: {
type: [Types.String]
},
max: {
type: [Types.String]
}
}
});
}
}]);
return Types;
}();
Types.typeStore = {};
Types.modelStore = {};
exports.default = Types;