@actonate/mirkwood/dist/utils/documentStore/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 _path = require('path');

var _path2 = _interopRequireDefault(_path);

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

var _types2 = _interopRequireDefault(_types);

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

var _resolver2 = _interopRequireDefault(_resolver);

var _couchdb = require('./couchdb');

var _couchdb2 = _interopRequireDefault(_couchdb);

var _graphql = require('graphql');

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

var _queries2 = _interopRequireDefault(_queries);

var _lodash = require('lodash');

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

    _classCallCheck(this, DocumentStoreUtility);

    // if documentstore config not found don't throw exception
    if (config) {
      this.config = config[process.env['NODE_ENV'] || 'development'];
    }

    if (!this.config) {
      this.client = null;
      return;
    }

    if (this.config.adapter === 'couchdb') {
      this.client = new _couchdb2.default(this.config);
    }
    this.resolvers = {
      create: this.createResolver.bind(this)
    };
  }

  _createClass(DocumentStoreUtility, [{
    key: 'createResolver',
    value: function createResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: _types2.default.generateType({
          fields: {
            _id: {
              type: _types2.default.ID
            }
          }
        }),
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {

          return client.create(modelName, args.input, args.store);
        })
      };
    }
  }, {
    key: 'updateResolver',
    value: function updateResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: type,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.update(modelName, args);
        })
      };
    }
  }, {
    key: 'deleteResolver',
    value: function deleteResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: type,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.delete(modelName, args);
        })
      };
    }
  }, {
    key: 'createDatabase',
    value: function createDatabase(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: type,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.createStore(args);
        })
      };
    }
  }, {
    key: 'replicateDatabase',
    value: function replicateDatabase(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: type,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.replicate(args);
        })
      };
    }
  }, {
    key: 'oneResolver',
    value: function oneResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: type,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {

          return client.one(modelName, args);
        })
      };
    }
  }, {
    key: 'fetchResolver',
    value: function fetchResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: _types2.default.generateType([type]),
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.fetch(modelName, args);
        })
      };
    }
  }, {
    key: 'viewResolver',
    value: function viewResolver(resolverName, type, model, inputSchema) {
      var client = this.client;
      var args = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;
      args = _extends({}, args);

      var argsObjects = _types2.default.generateArgs(args, inputSchema.name);
      return {
        type: _types2.default.generateType([type]),
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.view(modelName, args);
        })
      };
    }
  }, {
    key: 'queries',
    value: function queries(type, inputType, model) {
      var schema = model.schema;
      var modelName = schema.name;
      return new _graphql.GraphQLObjectType({
        name: [modelName, 'documentStore_Queries'].join(''),
        fields: {
          one: this.oneResolver('documentstore.one', type, model, {
            args: {
              _id: {
                type: _types2.default.ID
              },
              store: {
                type: _types2.default.String
              }
            }
          }),
          all: this.fetchResolver('documentstore.fetch', type, model, {
            args: {
              store: {
                type: _types2.default.String
              },
              key: {
                type: _types2.default.ID
              },
              keys: {
                type: [_types2.default.ID]
              },
              startkey: {
                type: [_types2.default.String]
              },
              endkey: {
                type: [_types2.default.String]
              }
            }
          }),
          view: this.viewResolver('documentstore.view', type, model, {
            args: {
              store: {
                type: _types2.default.String
              },
              key: {
                type: _types2.default.ID
              },
              keys: {
                type: [_types2.default.ID]
              },
              startkey: {
                type: [_types2.default.String]
              },
              endkey: {
                type: [_types2.default.String]
              },
              design: {
                type: _types2.default.String
              },
              view: {
                type: _types2.default.String
              }
            }
          })
        }
      });
    }
  }, {
    key: 'mutations',
    value: function mutations(type, inputType, model) {
      var schema = model.schema;
      var modelName = schema.name;
      return new _graphql.GraphQLObjectType({
        name: [modelName, 'documentStore_Mutation'].join(''),
        fields: {
          createStore: this.createDatabase('documentstore.createStore', _types2.default.Boolean, model, {
            args: {
              name: {
                type: _types2.default.String
              }
            }
          }),
          replicate: this.replicateDatabase('documentstore.replicate', _types2.default.Boolean, model, {
            args: {
              source: {
                type: _types2.default.String
              },
              target: {
                type: _types2.default.String
              },
              createTarget: {
                type: _types2.default.Boolean
              }
            }
          }),
          create: this.createResolver('documentstore.create', type, model, {
            args: {
              input: {
                type: inputType
              },
              store: {
                type: _types2.default.String
              }
            }
          }),
          update: this.updateResolver('documentstore.update', _types2.default.Boolean, model, {
            args: {
              input: {
                type: inputType
              },
              store: {
                type: _types2.default.String
              },
              _id: {
                type: _types2.default.ID
              }
            }
          }),
          delete: this.deleteResolver('documentstore.delete', _types2.default.Boolean, model, {
            args: {
              _id: {
                type: _types2.default.ID
              },
              store: {
                type: _types2.default.String
              },
              _rev: {
                type: _types2.default.ID
              }
            }
          })
        }
      });
    }
  }]);

  return DocumentStoreUtility;
}();

exports.default = DocumentStoreUtility;