@actonate/mirkwood/dist/utils/elasticsearch/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 _elasticsearch = require('./elasticsearch');

var _elasticsearch2 = _interopRequireDefault(_elasticsearch);

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

    _classCallCheck(this, ElasticsearchUtility);

    this.client = new _elasticsearch2.default({ config: config });
    this.resolvers = {
      index: this.indexResolver.bind(this),
      match: this.matchResolver.bind(this),
      term: this.termResolver.bind(this),
      range: this.rangeResolver.bind(this),
      search: this.searchResolver.bind(this),
      raw: this.rawResolver.bind(this),
      bulk: this.bulkResolver.bind(this),
      delete: this.deleteResolver.bind(this)
    };

    this.context = {
      connection: this.client
    };
  }

  _createClass(ElasticsearchUtility, [{
    key: 'queryReturnTypeGenerator',
    value: function queryReturnTypeGenerator(resolvedTypeName, type) {
      var resolvedType = _types2.default.generateType({
        name: [resolvedTypeName, 'Elastic_Search'].join(''),
        fields: {
          total: {
            type: _types2.default.Int
          },
          maxScore: {
            type: _types2.default.Float
          },
          hits: {
            type: _types2.default.List(_types2.default.generateType({
              name: [resolvedTypeName, 'Elastic_Search_Hit'].join(''),
              fields: {
                _id: {
                  type: _types2.default.ID
                },
                source: {
                  type: type
                },
                score: {
                  type: _types2.default.Float
                }
              }
            }))
          }
        }
      });
      return resolvedType;
    }
  }, {
    key: 'rawResolver',
    value: function rawResolver(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.Boolean,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.search(modelName, args.input);
        })
      };
    }
  }, {
    key: 'indexResolver',
    value: function indexResolver(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.Boolean,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.index(modelName, args._id, args.input);
        })
      };
    }
  }, {
    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: _types2.default.Boolean,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return client.delete(modelName, args._id);
        })
      };
    }
  }, {
    key: 'bulkResolver',
    value: function bulkResolver(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.Boolean,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {

          return client.index(modelName, args._id, args.input);
        })
      };
    }
  }, {
    key: 'generateMatchType',
    value: function generateMatchType(model) {
      var schema = model.schema;
      var modelName = schema.name;

      var matchTypeName = [modelName, 'Match'].join('_');

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

      return _types2.default.generateInputType({
        name: matchTypeName,
        fields: schema.fields
      }, ['defaultValue']); // sp that defaultValue is filtered out
    }
  }, {
    key: 'matchResolver',
    value: function matchResolver(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);
      var resolvedTypeName = [modelName, inputSchema.name].join('');
      var resolvedType = this.queryReturnTypeGenerator(resolvedTypeName, type);
      return {
        type: resolvedType,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          var newfield = [];
          (0, _lodash.map)(args.input.fields, function (field) {
            var field_data = [field.name, field.boost || 1].join('^');
            newfield.push(field_data);
          });
          var match = {
            query: {
              multi_match: {
                query: args.input.query,
                fields: newfield,
                fuzziness: args.input.fuzziness || 2
              }
            }
          };
          return client.search(modelName, match);
        })
      };
    }
  }, {
    key: 'termResolver',
    value: function termResolver(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);
      var resolvedTypeName = [modelName, inputSchema.name].join('');
      var resolvedType = this.queryReturnTypeGenerator(resolvedTypeName, type);
      return {
        type: resolvedType,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          var term = {};
          term[args.input.field] = args.input.value;
          var match = {
            query: {
              terms: term
            }
          };
          return client.search(modelName, match);
        })
      };
    }
  }, {
    key: 'rangeResolver',
    value: function rangeResolver(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);
      var resolvedTypeName = [modelName, inputSchema.name].join('');
      var resolvedType = this.queryReturnTypeGenerator(resolvedTypeName, type);
      return {
        type: resolvedType,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          var result = {};
          var arr = args.input;
          arr.map(function (itm) {
            (0, _lodash.set)(result, itm.field + '.' + itm.operator, itm.value);
          });
          var match = {
            query: {
              range: result
            }
          };
          return client.search(modelName, match);
        })
      };
    }
  }, {
    key: 'searchResolver',
    value: function searchResolver(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);
      var resolvedTypeName = [modelName, inputSchema.name].join('');
      var resolvedType = this.queryReturnTypeGenerator(resolvedTypeName, type);
      return {
        type: resolvedType,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          var query = [];
          var newfield = [];
          if (args.match) {
            args.match.fields.map(function (field) {
              var field_data = [field.name, field.boost].join('^');
              newfield.push(field_data);
            });
            var matchData = {
              multi_match: {
                query: args.match.query,
                fields: newfield,
                fuzziness: args.match.fuzziness || 2
              }
            };
            query.push(matchData);
          }
          if (args.range) {
            args.range.map(function (rangeData) {
              var data = {};
              data[rangeData.field] = {
                gte: rangeData.greaterThanEqual,
                lte: rangeData.lessThanEqual,
                boost: rangeData.boost
              };
              var ranges = {};
              ranges["range"] = data;
              query.push(ranges);
            });
          }
          if (args.term) {
            args.term.map(function (termData) {
              var term = {};
              var terms = {};
              term[termData.field] = termData.value;
              terms["terms"] = term;
              query.push(terms);
            });
          }
          var match = {
            query: {
              dis_max: {
                tie_breaker: args.tie_breaker || 0,
                boost: args.boost,
                queries: [{
                  bool: {
                    must: query
                  }
                }]
              }
            }
          };
          return client.search(modelName, match);
        })
      };
    }
  }, {
    key: 'mutations',
    value: function mutations(type, inputType, model) {
      var schema = model.schema;
      var modelName = schema.name;
      return new _graphql.GraphQLObjectType({
        name: [modelName, 'Elastic_Mutation'].join(''),
        fields: {
          index: this.indexResolver('elasticsearch.index', _types2.default.Boolean, model, {
            args: {
              _id: {
                type: _types2.default.ID
              },
              input: {
                type: inputType
              }
            }
          }),
          delete: this.deleteResolver('elasticsearch.delete', _types2.default.Boolean, model, {
            args: {
              _id: {
                type: _types2.default.ID
              }
            }
          })
          // bulk: this.bulkResolver('elasticsearch.bulkIndex', Types.Boolean, model, {
          //   args: {
          //     operation_type: {
          //       type: Types.Enum([modelName, 'operationType'].join(''), {
          //         'INDEX': {
          //           value: 'index'
          //         },
          //         'UPDATE': {
          //           value: 'update'
          //         },
          //         'DELETE': {
          //           value: 'delete'
          //         }
          //       })
          //     }
          //   }
          // })
        }
      });
    }
  }, {
    key: 'queries',
    value: function queries(type, inputType, model) {
      var schema = model.schema;
      var modelName = schema.name;

      var elasticQueryMatchFieldType = _types2.default.generateInputType({
        name: [modelName, 'Elastic_Query_Field'].join(''),
        fields: {
          name: {
            type: _types2.default.String
          },
          boost: {
            type: _types2.default.Float
          }
        }
      });

      var matchFieldType = _types2.default.generateInputType({
        name: [modelName, 'Elastic_Query_Match_Field'].join(''),
        fields: {
          query: {
            type: _types2.default.String
          },
          fields: {
            type: _types2.default.List(elasticQueryMatchFieldType)
          },
          fuzziness: {
            type: _types2.default.Int
          }
        }
      });
      var termFieldType = _types2.default.generateInputType({
        name: [modelName, 'Elastic_Query_Term_Field'].join(''),
        fields: {
          field: {
            type: _types2.default.String
          },
          value: {
            type: _types2.default.List(_types2.default.String)
          }
        }
      });
      var rangeFieldType = _types2.default.generateInputType({
        name: [modelName, 'Elastic_Query_Range_Field'].join(''),
        fields: {
          field: {
            type: _types2.default.String
          },
          operator: {
            type: _types2.default.Enum([modelName, 'operator'].join(''), {
              'GREATERTHANEQUAL': {
                value: 'gte'
              },
              'LESSTHANEQUAL': {
                value: 'lte'
              },
              'LESSTHAN': {
                value: 'lt'
              },
              'GREATERTHAN': {
                value: 'gt'
              }
            })
          },
          value: {
            type: _types2.default.Float,
            defaultValue: 1
          }
        }
      });

      return new _graphql.GraphQLObjectType({
        name: [modelName, 'Elastic_Query'].join(''),
        fields: {

          match: this.matchResolver('elasticsearch.match', type, model, {
            args: {
              input: {
                type: matchFieldType
              }
            }
          }),
          term: this.termResolver('elasticsearch.term', type, model, {
            args: {
              input: {
                type: termFieldType
              }
            }
          }),
          range: this.rangeResolver('elasticsearch.range', type, model, {
            args: {
              input: {
                type: _types2.default.List(rangeFieldType)
              },
              boost: {
                type: _types2.default.Float
              }
            }
          }),
          search: this.searchResolver('elasticsearch.search', type, model, {
            args: {
              range: {
                type: _types2.default.List(rangeFieldType)
              },
              term: {
                type: _types2.default.List(termFieldType)
              },
              match: {
                type: matchFieldType
              },
              boost: {
                type: _types2.default.Float
              },
              tie_breaker: {
                type: _types2.default.Float
              }
            }
          })
        }
      });
    }
  }]);

  return ElasticsearchUtility;
}();

exports.default = ElasticsearchUtility;