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

GraphQL based Rapid Server-side Development framework

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

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 _database = require('./database');

var _database2 = _interopRequireDefault(_database);

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

var _resolver2 = _interopRequireDefault(_resolver);

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

	_createClass(DatabaseMutations, [{
		key: 'resolvers',
		value: function resolvers() {
			return {
				create: this.createResolver,
				update: this.updateResolver,
				destroy: this.destroyResolver
			};
		}
	}, {
		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_Mutation'].join(''),
				fields: {
					create: this.createResolver('database.create', type, model, {
						args: {
							input: {
								type: inputType
							}
						}
					}),
					createMany: this.createResolver('database.create', type, model, {
						args: {
							input: {
								type: [inputType]
							}
						}
					}),
					update: this.updateResolver('database.update', type, model, {
						args: {
							_id: {
								type: _types2.default.ID,
								deprecationReason: 'Use find argument instead of _id as it supports more options'
							},
							find: {
								type: _database2.default.generateFindType(model)
							},
							input: {
								type: DatabaseMutations.generateUpdateType(model)
							}
						}
					}),
					destroy: this.destroyResolver('database.destroy', type, model, {
						args: {
							_id: {
								type: _types2.default.ID,
								deprecationReason: 'Use find argument instead of _id as it supports more options'
							},
							find: {
								type: _database2.default.generateFindType(model)
							}
						}
					}),
					delete: this.deleteResolver('database.delete', type, model, {
						args: {
							_id: {
								type: _types2.default.ID,
								deprecationReason: 'Use find argument instead of _id as it supports more options'
							},
							find: {
								type: _database2.default.generateFindType(model)
							}
						}
					})
				}
			});
		}
	}, {
		key: 'createResolver',
		value: function createResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;
			var argsObjects = _types2.default.generateArgs(args, inputSchema.name);

			return {
				type: Array.isArray(args.input.type) ? _types2.default.Int : type,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					var input = args.input; // take first property

					var result = new Promise(function (resolve, reject) {

						if (Array.isArray(input)) {
							_database2.default.createMany(modelDatasource, input).then(function (count) {
								resolve(count);
							}).catch(reject);
						} else {
							_database2.default.create(modelDatasource, input).then(function (res) {
								resolve(res);
							}).catch(reject);
						}
					});
					return result;
				})
			};
		}
	}, {
		key: 'updateResolver',
		value: function updateResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			// check if where 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: _graphql.GraphQLBoolean,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					if (!args.find) {
						args.find = { _id: args._id };
					}

					var find = args.find;
					var input = args.input;

					var result = new Promise(function (resolve, reject) {
						_database2.default.update(modelDatasource, find, input).then(function (res) {
							resolve(res);
						});
					});
					return result;
				})
			};
		}
	}, {
		key: 'deleteResolver',
		value: function deleteResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			// check if where 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: _graphql.GraphQLBoolean,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					if (!args.find) {
						args.find = { _id: args._id };
					}

					var find = args.find;

					var result = new Promise(function (resolve, reject) {
						_database2.default.delete(modelDatasource, find).then(function (res) {
							resolve(res);
						});
					});
					return result;
				})
			};
		}
	}, {
		key: 'destroyResolver',
		value: function destroyResolver(resolverName, type, model, inputSchema) {
			var modelDatasource = model.schema.datasource;
			var args = inputSchema.args;

			// check if where 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: _graphql.GraphQLBoolean,
				args: argsObjects,
				resolve: new _resolver2.default(resolverName, function (_, args) {
					if (!args.find) {
						args.find = { _id: args._id };
					}

					var find = args.find;

					var result = new Promise(function (resolve, reject) {
						_database2.default.destroy(modelDatasource, find).then(function (res) {
							resolve(res);
						});
					});
					return result;
				})
			};
		}
	}], [{
		key: 'generateUpdateType',
		value: function generateUpdateType(model) {
			var schema = model.schema;
			var modelName = schema.name;

			var updateTypeName = [modelName, 'Update'].join('_');

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

			return _types2.default.generateInputType({
				name: updateTypeName,
				fields: schema.fields
			}, ['defaultValue']); // sp that defaultValue is filtered out
		}
	}]);

	return DatabaseMutations;
}();

exports.default = new DatabaseMutations();