@actonate/mirkwood/dist/utils/database/queries.js

GraphQL based Rapid Server-side Development framework

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

var _types2 = _interopRequireDefault(_types);

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

var _resolver2 = _interopRequireDefault(_resolver);

var _database = require('./database');

var _database2 = _interopRequireDefault(_database);

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 DatabaseQueries = function () {
	function DatabaseQueries() {
		_classCallCheck(this, DatabaseQueries);
	}

	_createClass(DatabaseQueries, [{
		key: 'resolvers',
		value: function resolvers() {
			return {
				one: this.oneResolver,
				all: this.allResolver,
				joinMany: this.joinManyResolver,
				joinOne: this.joinOneResolver
			};
		}
	}, {
		key: 'generate',
		value: function generate(type, inputType, model) {
			var schema = model.schema;

			var modelDatasource = schema.datasource;
			var modelName = schema.name;

			return new _graphql.GraphQLObjectType({
				name: [modelName, 'Database_Query'].join(''),
				fields: {
					one: this.oneResolver('database.one', type, model, {
						args: {
							find: {
								type: _database2.default.generateFindType(model)
							},
							query: {
								type: DatabaseQueries.generateQueryType(type, model)
							}
						}
					}),
					all: this.allResolver('database.all', type, model, {
						args: {
							find: {
								type: _database2.default.generateFindType(model)
							},
							query: {
								type: DatabaseQueries.generateQueryType(type, model)
							}
						}
					}),
					count: this.countResolver('database.count', type, model, {
						args: {
							find: {
								type: _database2.default.generateFindType(model)
							},
							query: {
								type: DatabaseQueries.generateQueryType(type, model)
							}
						}
					})
				}
			});
		}
	}, {
		key: 'allResolver',
		value: function allResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			args = _extends({
				skip: {
					type: _types2.default.Int,
					defaultValue: 0
				},
				limit: {
					type: _types2.default.Int,
					defaultValue: 100
				},
				distinct: {
					type: [_types2.default.String]
				},
				sort: {
					type: _types2.default.SortType
				},
				aggregate: {
					type: _types2.default.AggregateType
				},
				orderBy: {
					type: [_types2.default.SortType]
				},
				groupBy: {
					type: [_types2.default.GroupByType]
				}
			}, args);

			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: _types2.default.List(type),
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					return _database2.default.all(modelDatasource, args);
				})
			};
		}
	}, {
		key: 'joinManyResolver',
		value: function joinManyResolver(resolverName, type, model, inputSchema) {
			var args = inputSchema.args;
			var modelDatasource = model.schema.datasource;

			args = _extends({
				skip: {
					type: _types2.default.Int,
					defaultValue: 0
				},
				limit: {
					type: _types2.default.Int,
					defaultValue: 100
				},
				find: {
					type: _database2.default.generateFindType(model)
				},
				query: {
					type: DatabaseQueries.generateQueryType(type, model)
				},
				sort: {
					type: _types2.default.SortType
				},
				orderBy: {
					type: [_types2.default.SortType]
				}
			}, args);

			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: _types2.default.List(type),
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (obj, args) {
					var field = args.field;
					var joinBy = args.joinBy;
					var joinValue = obj[joinBy];

					var dbArgs = {
						skip: args.skip,
						limit: args.limit,
						sort: args.sort,
						orderBy: args.orderBy,
						find: args.find || {},
						query: args.query
					};

					if (joinValue === null) {
						return Promise.resolve(null);
					}

					// add join condition
					if (Array.isArray(joinValue)) {
						dbArgs.find[field] = joinValue;
					} else {
						dbArgs.find[field] = joinValue.toString();
					}

					return _database2.default.all(modelDatasource, dbArgs);
				})
			};
		}
	}, {
		key: 'joinOneResolver',
		value: function joinOneResolver(resolverName, type, model, inputSchema) {
			var args = inputSchema.args;
			var modelDatasource = model.schema.datasource;

			args = _extends({
				find: {
					type: _database2.default.generateFindType(model)
				},
				query: {
					type: DatabaseQueries.generateQueryType(type, model)
				}
			}, args);

			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: type,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (obj, args) {
					var field = args.field;
					var joinBy = args.joinBy;
					var joinValue = obj[joinBy];

					var find = args.find || {};
					var query = args.query;

					if (joinValue === null) {
						return Promise.resolve(null);
					}

					find[field] = joinValue.toString();

					return _database2.default.one(modelDatasource, { find: find, query: query });
				})
			};
		}
	}, {
		key: 'countResolver',
		value: function countResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			args = _extends({}, args);

			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: _types2.default.Int,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					return _database2.default.count(modelDatasource, args);
				})
			};
		}
	}, {
		key: 'oneResolver',
		value: function oneResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			args = _extends({}, args, {
				aggregate: {
					type: _types2.default.AggregateType
				}
				// check if where find is not specified then generate default
			});if (!args.find && !args._id) {
				args.find = {
					fields: {
						_id: {
							type: _types2.default.ID
						}
					}
				};
			}

			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: type,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, resolverArgs) {
					var transformedArgs = resolverArgs;
					if (args._id) {
						args.find = { _id: args._id };
					}

					var find = transformedArgs.find,
					    query = transformedArgs.query,
					    aggregate = transformedArgs.aggregate;


					return _database2.default.one(modelDatasource, { find: find, query: query, aggregate: aggregate });
				})
			};
		}
	}], [{
		key: 'generateQueryFieldsSchema',
		value: function generateQueryFieldsSchema(schema, typeName) {
			var queryFieldSchema = {};

			var _iteratorNormalCompletion = true;
			var _didIteratorError = false;
			var _iteratorError = undefined;

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

					var field = schema.fields[key];
					var fieldType = field.type;

					if (field.resolve) {
						continue;
					}

					var queryFieldsTypeFieldsName = [typeName, key].join('_');

					if ((typeof fieldType === 'undefined' ? 'undefined' : _typeof(fieldType)) === 'object' && fieldType.fields) {
						queryFieldSchema[key] = {
							type: _types2.default.generateInputType({
								name: queryFieldsTypeFieldsName,
								fields: DatabaseQueries.generateQueryFieldsSchema(fieldType, queryFieldsTypeFieldsName)
							})
						};
						continue;
					}

					if (Array.isArray(fieldType) && fieldType[0].fields) {
						queryFieldSchema[key] = {
							type: _types2.default.generateInputType({
								name: queryFieldsTypeFieldsName,
								fields: DatabaseQueries.generateQueryFieldsSchema(fieldType[0], queryFieldsTypeFieldsName)
							})
						};
						continue;
					}

					queryFieldSchema[key] = {
						type: _types2.default.generateInputType({
							name: queryFieldsTypeFieldsName,
							fields: {
								operator: {
									type: _types2.default.OperatorType,
									required: true
								},
								value: {
									type: field.type
								},
								values: {
									type: _types2.default.generateInputType([field.type]),
									defaultValue: []
								},
								options: {
									type: {
										name: [queryFieldsTypeFieldsName, 'options'].join('_'),
										fields: {
											match: {
												type: _types2.default.String,
												description: "Specifiy additional options to pass for regular expression matching"
											}
										}
									}
								}
							}
						})
					};
				}
			} catch (err) {
				_didIteratorError = true;
				_iteratorError = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion && _iterator.return) {
						_iterator.return();
					}
				} finally {
					if (_didIteratorError) {
						throw _iteratorError;
					}
				}
			}

			return queryFieldSchema;
		}
	}, {
		key: 'generateQueryFieldsType',
		value: function generateQueryFieldsType(type, model) {
			var schema = model.schema;

			var modelDatasource = schema.datasource;
			var modelName = schema.name;

			var queryFieldsTypeName = [modelName, 'Fields'].join('_');

			var queryFieldsTypeFields = DatabaseQueries.generateQueryFieldsSchema(schema, queryFieldsTypeName);

			return _types2.default.generateInputType({
				name: queryFieldsTypeName,
				fields: queryFieldsTypeFields
			});
		}
	}, {
		key: 'generateQueryType',
		value: function generateQueryType(type, model) {
			var schema = model.schema;

			var modelDatasource = schema.datasource;
			var modelName = schema.name;

			var queryTypeName = [modelName, 'QueryType'].join('_');

			// fetch if exists
			if (_types2.default.get(queryTypeName)) {
				return _types2.default.get(queryTypeName);
			}

			var queryType = new _graphql.GraphQLInputObjectType({
				name: queryTypeName,
				fields: function fields() {
					return {
						fields: {
							type: DatabaseQueries.generateQueryFieldsType(type, model)
						},
						and: {
							type: new _graphql.GraphQLList(queryType)
						},
						or: {
							type: new _graphql.GraphQLList(queryType)
						},
						not: {
							type: new _graphql.GraphQLList(queryType)
						}
					};
				}
			});

			// store for future refs
			_types2.default.store(queryTypeName, queryType);
			return queryType;
		}
	}]);

	return DatabaseQueries;
}();

exports.default = new DatabaseQueries();