@actonate/mirkwood/dist/lib/schemagen.js

GraphQL based Rapid Server-side Development framework

'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 _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 _types = require('./types');

var _types2 = _interopRequireDefault(_types);

var _resolver = require('./resolver');

var _resolver2 = _interopRequireDefault(_resolver);

var _meta = require('./meta');

var _meta2 = _interopRequireDefault(_meta);

var _orm = require('./orm');

var _orm2 = _interopRequireDefault(_orm);

var _utils = require('../utils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SchemaGenerator = function () {
	function SchemaGenerator(_ref) {
		var config = _ref.config;

		_classCallCheck(this, SchemaGenerator);

		this.utils = {
			database: new _utils.DatabaseUtility({ config: config.database }),
			email: new _utils.EmailUtility({ config: config.email }),
			elasticsearch: new _utils.ElasticsearchUtility({ config: config.elasticsearch }),
			documentstore: new _utils.DocumentStoreUtility({ config: config.documentstore }),
			http: new _utils.HttpUtility(),
			session: new _utils.SessionUtility(),
			fs: new _utils.FsUtility(),
			export: new _utils.ExportUtility(),
			awsS3: new _utils.AWSS3Utility({ config: config.aws }),
			image: new _utils.ImageUtility(),
			queue: new _utils.QueueUtility({ config: config.queue })
		};
		this.orm = new _orm2.default({ config: config.database });
	}

	_createClass(SchemaGenerator, [{
		key: 'generate',
		value: function generate(models) {
			var _this = this;

			var graphQLQueryObjects = {};
			var graphQLQueryObjectsWithInternal = {};
			var graphQLMutationObjects = {};
			var graphQLMutationsObjectsWithInternal = {};

			// Generate Model Type / Model Input Types
			var _iteratorNormalCompletion = true;
			var _didIteratorError = false;
			var _iteratorError = undefined;

			try {
				for (var _iterator = Object.keys(models)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
					var key = _step.value;

					// set defaults
					var _schema = models[key].schema;
					_schema.name = _schema.name ? _schema.name : key;
					models[key].key = key;

					var model = this._extendModel(models[key]);

					// Store model
					_types2.default.storeModel(_extends({}, model));

					// Generate Type
					model.typeInstance = this._generateModelType(model);
					model.inputTypeInstance = this._generateModelInputType(model);
				}

				// Generate Mutations & Queries
			} catch (err) {
				_didIteratorError = true;
				_iteratorError = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion && _iterator.return) {
						_iterator.return();
					}
				} finally {
					if (_didIteratorError) {
						throw _iteratorError;
					}
				}
			}

			var _iteratorNormalCompletion2 = true;
			var _didIteratorError2 = false;
			var _iteratorError2 = undefined;

			try {
				var _loop = function _loop() {
					var key = _step2.value;

					// set defaults
					var schema = models[key].schema;
					var model = models[key];

					var graphQLModelType = model.typeInstance;
					var graphQLModelInputType = model.inputTypeInstance;

					// Generate Queries, Mutations

					var _generateQueries2 = _this._generateQueries(graphQLModelType, graphQLModelInputType, model),
					    graphQLQueries = _generateQueries2.graphQLQueries,
					    graphQLQueriesWithInternal = _generateQueries2.graphQLQueriesWithInternal;

					var _generateMutations2 = _this._generateMutations(graphQLModelType, graphQLModelInputType, model),
					    graphQLMutations = _generateMutations2.graphQLMutations,
					    graphQLMutationsWithInternal = _generateMutations2.graphQLMutationsWithInternal;

					graphQLQueryObjects[key] = {
						type: graphQLQueries,
						resolve: function resolve(_, args, ctx, info) {
							ctx.model = key;
							return true;
						}
					};

					graphQLQueryObjectsWithInternal[key] = {
						type: graphQLQueriesWithInternal,
						resolve: function resolve(_, args, ctx, info) {
							ctx.model = key;
							return true;
						}
					};

					graphQLMutationObjects[key] = {
						type: graphQLMutations,
						resolve: function resolve(_, args, ctx, info) {
							ctx.model = key;
							return true;
						}
					};

					graphQLMutationsObjectsWithInternal[key] = {
						type: graphQLMutationsWithInternal,
						resolve: function resolve(_, args, ctx, info) {
							ctx.model = key;
							return true;
						}
					};
				};

				for (var _iterator2 = Object.keys(models)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
					_loop();
				}
			} catch (err) {
				_didIteratorError2 = true;
				_iteratorError2 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion2 && _iterator2.return) {
						_iterator2.return();
					}
				} finally {
					if (_didIteratorError2) {
						throw _iteratorError2;
					}
				}
			}

			var graphQLMetaType = _meta2.default.generateRootMetaType();

			graphQLQueryObjects['meta'] = {
				type: graphQLMetaType,
				resolve: function resolve() {
					return true;
				}
			};

			graphQLQueryObjectsWithInternal['meta'] = {
				type: graphQLMetaType,
				resolve: function resolve() {
					return true;
				}

				// Generate the Schemas
			};var schema = new _graphql.GraphQLSchema({
				query: new _graphql.GraphQLObjectType({
					name: 'RootQuery',
					fields: graphQLQueryObjects
				}),
				mutation: new _graphql.GraphQLObjectType({
					name: 'RootMutation',
					fields: graphQLMutationObjects
				})
			});

			var internalSchema = new _graphql.GraphQLSchema({
				query: new _graphql.GraphQLObjectType({
					name: 'RootQuery',
					fields: graphQLQueryObjectsWithInternal
				}),
				mutation: new _graphql.GraphQLObjectType({
					name: 'RootMutation',
					fields: graphQLMutationsObjectsWithInternal
				})
			});

			// Build & Initialize ORM
			this.orm.initialize({ models: models });

			// Return GraphQL Schema
			return { schema: schema, internalSchema: internalSchema };
		}
	}, {
		key: '_extendModel',
		value: function _extendModel(model) {
			var modelSchema = model.schema;
			modelSchema.datasource = modelSchema.datasource || {};

			if (modelSchema.datasource.timestamps) {
				modelSchema.fields = _extends({}, modelSchema.fields, {
					_created_at: {
						type: _types2.default.String,
						label: 'Created',
						descriptor: 'date'
					},
					_updated_at: {
						label: 'Updated',
						type: _types2.default.String,
						descriptor: 'date'
					}
				});
			}

			return model;
		}
	}, {
		key: '_generateModelType',
		value: function _generateModelType(model) {
			model = this._generateModelRelations(model);
			model = this._generateAggregates(model);

			// Generate GraphQL Object type
			return _types2.default.generateType(model.schema);
		}
	}, {
		key: '_generateModelInputType',
		value: function _generateModelInputType(model) {
			// Generate GraphQL Input Object type
			model.schema.fields = _extends({}, model.schema.fields);

			// delete related field
			if (model.schema.fields._children) {
				delete model.schema.fields._children;
			}
			// delete aggregates field
			if (model.schema.fields._aggregates) {
				delete model.schema.fields._aggregates;
			}
			// TODO: Remove parent and _child
			return _types2.default.generateInputType(model.schema);
		}
	}, {
		key: '_generateQueries',
		value: function _generateQueries(type, inputType, model) {
			var queries = model.queries ? model.queries : {};
			var modelQueryObjects = {};
			var modelQueryInternalObjects = {};

			var _iteratorNormalCompletion3 = true;
			var _didIteratorError3 = false;
			var _iteratorError3 = undefined;

			try {
				for (var _iterator3 = Object.keys(this.utils)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
					var util = _step3.value;

					var utilQueryType = this.utils[util].queries(type, inputType, model);

					if (utilQueryType) {
						modelQueryObjects[util] = {
							type: utilQueryType,
							resolve: function resolve() {
								return true;
							}
						};
					}
				}
			} catch (err) {
				_didIteratorError3 = true;
				_iteratorError3 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion3 && _iterator3.return) {
						_iterator3.return();
					}
				} finally {
					if (_didIteratorError3) {
						throw _iteratorError3;
					}
				}
			}

			var _iteratorNormalCompletion4 = true;
			var _didIteratorError4 = false;
			var _iteratorError4 = undefined;

			try {
				for (var _iterator4 = Object.keys(queries)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
					var key = _step4.value;

					var iterQuery = queries[key];
					var iterQueryType = iterQuery.type ? _types2.default.generateType(iterQuery.type) : type;

					if (typeof iterQuery.resolve === 'string') {

						var resolverUtility = iterQuery.resolve.split('.')[0];
						var resolverUtilityAction = iterQuery.resolve.split('.')[1];
						var resolverFunction = this.utils[resolverUtility].resolvers[resolverUtilityAction];

						if (!iterQuery.internal) {
							modelQueryObjects[key] = resolverFunction(key, iterQueryType, model, iterQuery);
						} else {
							modelQueryInternalObjects[key] = resolverFunction(key, iterQueryType, model, iterQuery);
						}
					} else if (typeof iterQuery.resolve === 'function') {
						// handle custom resolvers

						if (!iterQuery.internal) {
							modelQueryObjects[key] = {
								type: iterQueryType,
								args: _types2.default.generateArgs(iterQuery.args, key),
								resolve: new _resolver2.default(key, iterQuery.resolve)
							};
						} else {
							modelQueryInternalObjects[key] = {
								type: iterQueryType,
								args: _types2.default.generateArgs(iterQuery.args, key),
								resolve: new _resolver2.default(key, iterQuery.resolve)
							};
						}
					}
				}

				// // extend modelQueryInternalObjects
			} catch (err) {
				_didIteratorError4 = true;
				_iteratorError4 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion4 && _iterator4.return) {
						_iterator4.return();
					}
				} finally {
					if (_didIteratorError4) {
						throw _iteratorError4;
					}
				}
			}

			modelQueryInternalObjects = _extends({}, modelQueryObjects, modelQueryInternalObjects);

			return {
				graphQLQueries: new _graphql.GraphQLObjectType({
					name: [model.schema.name, 'Queries'].join(''),
					fields: modelQueryObjects
				}),
				graphQLQueriesWithInternal: new _graphql.GraphQLObjectType({
					name: [model.schema.name, 'QueriesWithInternal'].join(''),
					fields: modelQueryInternalObjects
				})
			};
		}
	}, {
		key: '_generateMutations',
		value: function _generateMutations(type, inputType, model) {
			var mutations = model.mutations ? model.mutations : {};
			var modelMutationObjects = {};
			var modelMutationInternalObjects = {};

			var _iteratorNormalCompletion5 = true;
			var _didIteratorError5 = false;
			var _iteratorError5 = undefined;

			try {
				for (var _iterator5 = Object.keys(this.utils)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
					var util = _step5.value;

					var utilMutationType = this.utils[util].mutations(type, inputType, model);

					if (utilMutationType) {
						modelMutationObjects[util] = {
							type: utilMutationType,
							resolve: function resolve() {
								return true;
							}
						};
					}
				}
			} catch (err) {
				_didIteratorError5 = true;
				_iteratorError5 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion5 && _iterator5.return) {
						_iterator5.return();
					}
				} finally {
					if (_didIteratorError5) {
						throw _iteratorError5;
					}
				}
			}

			var _iteratorNormalCompletion6 = true;
			var _didIteratorError6 = false;
			var _iteratorError6 = undefined;

			try {
				for (var _iterator6 = Object.keys(mutations)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
					var key = _step6.value;

					var iterMutation = mutations[key];
					var iterMutationType = iterMutation.type ? _types2.default.generateType(iterMutation.type) : type;

					if (typeof iterMutation.resolve === 'string') {

						var resolverUtility = iterMutation.resolve.split('.')[0];
						var resolverUtilityAction = iterMutation.resolve.split('.')[1];
						var resolverFunction = this.utils[resolverUtility].resolvers[resolverUtilityAction];

						if (!iterMutation.internal) {
							modelMutationObjects[key] = resolverFunction(key, iterMutationType, model, iterMutation);
						} else {
							modelMutationInternalObjects[key] = resolverFunction(key, iterMutationType, model, iterMutation);
						}
					} else if (typeof iterMutation.resolve === 'function') {
						// handle custom resolvers
						if (!iterMutation.internal) {
							modelMutationObjects[key] = {
								type: iterMutationType,
								args: _types2.default.generateArgs(iterMutation.args, key),
								resolve: new _resolver2.default(key, iterMutation.resolve)
							};
						} else {
							modelMutationInternalObjects[key] = {
								type: iterMutationType,
								args: _types2.default.generateArgs(iterMutation.args, key),
								resolve: new _resolver2.default(key, iterMutation.resolve)
							};
						}
					}
				}

				// extend modelQueryInternalObjects
			} catch (err) {
				_didIteratorError6 = true;
				_iteratorError6 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion6 && _iterator6.return) {
						_iterator6.return();
					}
				} finally {
					if (_didIteratorError6) {
						throw _iteratorError6;
					}
				}
			}

			modelMutationInternalObjects = _extends({}, modelMutationObjects, modelMutationInternalObjects);

			return {
				graphQLMutations: new _graphql.GraphQLObjectType({
					name: [model.schema.name, 'Mutations'].join(''),
					fields: modelMutationObjects
				}),
				graphQLMutationsWithInternal: new _graphql.GraphQLObjectType({
					name: [model.schema.name, 'MutationsWithInternal'].join(''),
					fields: modelMutationInternalObjects
				})
			};
		}
	}, {
		key: 'getSchemaContext',
		value: function getSchemaContext() {
			var utils = this.utils;

			var utilsContext = {};

			var _iteratorNormalCompletion7 = true;
			var _didIteratorError7 = false;
			var _iteratorError7 = undefined;

			try {
				for (var _iterator7 = Object.keys(utils)[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
					var name = _step7.value;

					if (utils[name].context) {
						utilsContext = _extends({}, utilsContext, _defineProperty({}, name, utils[name].context));
					}
				}

				// orm
			} catch (err) {
				_didIteratorError7 = true;
				_iteratorError7 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion7 && _iterator7.return) {
						_iterator7.return();
					}
				} finally {
					if (_didIteratorError7) {
						throw _iteratorError7;
					}
				}
			}

			return {
				utils: utilsContext,
				orm: this.orm.getConnection()
			};
		}
	}, {
		key: '_generateAggregates',
		value: function _generateAggregates(model) {
			// add aggregates support
			return this.utils.database.aggregates(model);
		}
	}, {
		key: '_generateModelRelations',
		value: function _generateModelRelations(model) {
			var modelSchema = model.schema;
			var modelRelations = modelSchema.relations;

			if (!modelRelations) {
				return model;
			}

			// update relations with the model
			return this.utils.database.relations(model);
		}
	}]);

	return SchemaGenerator;
}();

exports.default = SchemaGenerator;