@actonate/mirkwood/dist/utils/database/index.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 _lodash = require('lodash');

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

var _database2 = _interopRequireDefault(_database);

var _mutations = require('./mutations');

var _mutations2 = _interopRequireDefault(_mutations);

var _queries = require('./queries');

var _queries2 = _interopRequireDefault(_queries);

var _types = require('../../lib/types');

var _types2 = _interopRequireDefault(_types);

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 DatabaseUtility = function () {
	function DatabaseUtility(_ref) {
		var config = _ref.config;

		_classCallCheck(this, DatabaseUtility);

		_database2.default.init({ config: config });
		this.resolvers = _extends({}, _queries2.default.resolvers(), _mutations2.default.resolvers());

		this.mutationResolvers = _mutations2.default.resolvers();
		this.context = {
			connection: _database2.default.getConnection
		};
	}

	_createClass(DatabaseUtility, [{
		key: 'mutations',
		value: function mutations(type, inputType, model) {
			return _mutations2.default.generate(type, inputType, model);
		}
	}, {
		key: 'queries',
		value: function queries(type, inputType, model) {
			return _queries2.default.generate(type, inputType, model);
		}
	}, {
		key: 'relations',
		value: function relations(model) {
			var _this = this;

			var modelSchema = model.schema;
			var modelRelations = modelSchema.relations;
			var modelName = model.schema.name;
			var modelKey = model.key;

			var modelFields = modelSchema.fields;

			// Children or hasMany
			if (modelRelations.children && Array.isArray(modelRelations.children)) {
				modelFields['_children'] = {
					type: {
						fields: function fields() {
							return _this._generateChildrenRelations(modelKey, modelRelations.children);
						}
					},
					resolve: function resolve(obj) {
						return obj;
					}
				};
			}

			// Child or hasOne
			if (modelRelations.child && Array.isArray(modelRelations.child)) {
				modelFields['_child'] = {
					type: {
						fields: function fields() {
							return _this._generateChildRelations(modelKey, modelRelations.child);
						}
					},
					resolve: function resolve(obj) {
						return obj;
					}
				};
			}

			// Parent or belongs
			if (modelRelations.parent && Array.isArray(modelRelations.parent)) {
				modelFields['_parent'] = {
					type: {
						fields: function fields() {
							return _this._generateParentRelations(modelKey, modelRelations.parent);
						}
					},
					resolve: function resolve(obj) {
						return obj;
					}
				};
			}

			return model;
		}
	}, {
		key: 'aggregates',
		value: function aggregates(model) {
			var modelSchema = model.schema;
			var modelRelations = modelSchema.relations;
			var modelName = model.schema.name;
			var modelKey = model.key;

			var modelFields = modelSchema.fields;

			var aggregateFields = (0, _lodash.pickBy)(modelFields, function (field) {
				return field.aggregate;
			});

			// skip if no aggregate fields
			if (!aggregateFields || (0, _lodash.keys)(aggregateFields).length === 0) {
				return model;
			}

			var modelAggregateFieldType = _types2.default.generateType({
				name: [modelName, 'AggregateFields'].join(''),
				fields: (0, _lodash.mapValues)(aggregateFields, function (value) {
					return _extends({}, value, {
						type: _types2.default.Float
					});
				})
			});

			var modelAggregatesType = _types2.default.generateType({
				name: [modelName, 'Aggregates'].join(''),
				fields: {
					sum: {
						type: modelAggregateFieldType
					},
					avg: {
						type: modelAggregateFieldType
					},
					count: {
						type: modelAggregateFieldType
					},
					min: {
						type: modelAggregateFieldType
					},
					max: {
						type: modelAggregateFieldType
					}
				}
			});

			modelFields['_aggregates'] = {
				type: modelAggregatesType
			};

			return model;
		}
	}, {
		key: '_generateChildrenRelations',
		value: function _generateChildrenRelations(modelKey, relations) {
			var _this2 = this;

			var childrenRelations = {};

			relations.forEach(function (relation) {
				var resolverName = [modelKey, 'children', relation.name].join('.');

				childrenRelations[relation.name] = _this2.resolvers['joinMany'](resolverName, _types2.default.get(relation.type), _types2.default.model(relation.model), {
					args: {
						field: {
							type: _types2.default.String,
							defaultValue: relation.field
						},
						joinBy: {
							type: _types2.default.String,
							defaultValue: relation.joinBy || '_id'
						}
					}
				});
			});

			return childrenRelations;
		}
	}, {
		key: '_generateChildRelations',
		value: function _generateChildRelations(modelKey, relations) {
			var _this3 = this;

			var childRelations = {};

			relations.forEach(function (relation) {
				var resolverName = [modelKey, 'child', relation.name].join('.');

				childRelations[relation.name] = _this3.resolvers['joinOne'](resolverName, _types2.default.get(relation.type), _types2.default.model(relation.model), {
					args: {
						field: {
							type: _types2.default.String,
							defaultValue: relation.field
						},
						joinBy: {
							type: _types2.default.String,
							defaultValue: relation.joinBy || '_id'
						}
					}
				});
			});

			return childRelations;
		}
	}, {
		key: '_generateParentRelations',
		value: function _generateParentRelations(modelKey, relations) {
			var _this4 = this;

			var parentRelations = {};

			relations.forEach(function (relation) {

				var resolverName = [modelKey, 'parent', relation.name].join('.');
				var relationTypeName = relation.type;
				var joinResolver = _this4.resolvers['joinOne'];

				// handle array case (multiple parents)
				if (Array.isArray(relationTypeName)) {
					joinResolver = _this4.resolvers['joinMany'];
					relationTypeName = relationTypeName[0];
				}

				parentRelations[relation.name] = joinResolver(resolverName, _types2.default.get(relationTypeName), _types2.default.model(relation.model), {
					args: {
						field: {
							type: _types2.default.String,
							defaultValue: relation.field || '_id'
						},
						joinBy: {
							type: _types2.default.String,
							defaultValue: relation.joinBy
						}
					}
				});
			});

			return parentRelations;
		}
	}]);

	return DatabaseUtility;
}();

exports.default = DatabaseUtility;