feat(QueryDSL): Add basic input types for search body

Author: nodkz

.eslintrc

@@ -19,11 +19,12 @@
       "functions": "ignore",
     }],
     "no-plusplus": 0,
-    "import/no-extraneous-dependencies": 0
+    "import/no-extraneous-dependencies": 0,
+    "import/prefer-default-export": 0,
   },
   "env": {
     "jasmine": true,
-    "jest": true
+    "jest": true,
   },
   "plugins": [
     "flowtype",

package.json

@@ -35,24 +35,24 @@
     "babel-eslint": "^7.1.1",
     "babel-plugin-transform-flow-strip-types": "^6.22.0",
     "babel-plugin-transform-object-rest-spread": "^6.22.0",
-    "babel-preset-env": "^1.1.8",
+    "babel-preset-env": "^1.2.1",
     "cz-conventional-changelog": "^2.0.0",
     "elasticsearch": "^12.1.3",
-    "eslint": "^3.14.1",
+    "eslint": "^3.17.1",
     "eslint-config-airbnb-base": "^11.0.1",
     "eslint-config-prettier": "^1.0.2",
-    "eslint-plugin-flowtype": "^2.30.0",
+    "eslint-plugin-flowtype": "^2.30.3",
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-prettier": "^2.0.0",
     "express": "^4.15.2",
     "express-graphql": "^0.6.3",
     "flow-bin": "^0.41.0",
     "graphql": "^0.9.1",
-    "graphql-compose": "^1.14.0",
+    "graphql-compose": "^1.15.0",
     "jest": "^19.0.2",
     "jest-babel": "^1.0.1",
     "npm-run-all": "^4.0.1",
-    "prettier": "^0.21.0",
+    "prettier": "^0.22.0",
     "rimraf": "^2.5.4",
     "semantic-release": "^6.3.2"
   },
@@ -70,9 +70,9 @@
     "build": "npm-run-all build:*",
     "build:lib": "rimraf lib && babel src --ignore __tests__,__mocks__ -d lib",
     "build:flow": "find ./src -name '*.js' -not -path '*/__*' | while read filepath; do cp $filepath `echo $filepath | sed 's/\\/src\\//\\/lib\\//g'`.flow; done",
-    "example": "nodemon -e js --exec ./node_modules/.bin/babel-node ./examples/elastic50/index.js",
+    "example": "nodemon -e js --ignore *test* --exec ./node_modules/.bin/babel-node ./examples/elastic50/index.js",
     "coverage": "jest --coverage",
-    "lint": "eslint src test *.js",
+    "lint": "eslint --ext .js ./src",
     "test": "jest",
     "test:watch": "jest --watch",
     "watch": "npm run test:watch",

src/ElasticApiParser.js

@@ -13,13 +13,14 @@ import {
   GraphQLNonNull,
 } from 'graphql';
 import { GraphQLJSON, upperFirst, TypeComposer } from 'graphql-compose';
+import { getSearchBodyITC } from './ElasticDSL/SearchBody';
 
 import type {
   GraphQLArgumentConfig,
   GraphQLFieldConfigArgumentMap,
   GraphQLFieldMap,
   GraphQLInputType,
-} from 'graphql/type/definition';
+} from 'graphql/type/definition'; // eslint-disable-line
 
 export type ElasticApiParserOptsT = {
   version?:
@@ -125,6 +126,12 @@ export default class ElasticApiParser {
 
       const elasticMethod = this.getMethodName(item.ctx.string);
 
+      if (elasticMethod === 'search') {
+        argMap.body.type = getSearchBodyITC({
+          prefix: this.prefix,
+        }).getType();
+      }
+
       result[item.ctx.string] = {
         type: GraphQLJSON,
         description,
@@ -253,8 +260,12 @@ export default class ElasticApiParser {
           return this.getEnumType(fieldName, paramCfg.options);
         }
         return GraphQLString;
+      case undefined:
+        // some fields may not have type definition in API file,
+        // eg '@param {anything} params.operationThreading - ?'
+        return GraphQLJSON;
       default:
-        console.log(`New type '${paramCfg.type}' in elastic params setting.`); // eslint-disable-line
+        console.log(`New type '${paramCfg.type}' in elastic params setting for field ${fieldName}.`); // eslint-disable-line
         return GraphQLJSON;
     }
   }

src/ElasticDSL/Query/Bool.js

@@ -0,0 +1,41 @@
+/* @flow */
+
+import { InputTypeComposer } from 'graphql-compose';
+import { getQueryITC } from './Query';
+import { getTypeName, getOrSetType } from "../../utils";
+
+export function getBoolITC(opts = {}): InputTypeComposer {
+  const typeName = getTypeName('QueryBool', opts);
+
+  return getOrSetType(typeName, () => {
+    const BoolITC = InputTypeComposer.create(typeName);
+    BoolITC.setDescription('A query that matches documents matching boolean combinations of other queries. The bool query maps to Lucene BooleanQuery. It is built using one or more boolean clauses, each clause with a typed occurrence. ');
+    BoolITC.setFields({
+      must: {
+        type: () => getQueryITC(opts),
+        description: 'The clause (query) must appear in matching documents and will contribute to the score.',
+      },
+      filter: {
+        type: () => getQueryITC(opts),
+        description: 'The clause (query) must appear in matching documents. However unlike must the score of the query will be ignored. Filter clauses are executed in filter context, meaning that scoring is ignored and clauses are considered for caching.',
+      },
+      should: {
+        type: () => getQueryITC(opts),
+        description: 'The clause (query) should appear in the matching document. In a boolean query with no must or filter clauses, one or more should clauses must match a document. The minimum number of should clauses to match can be set using the minimum_should_match parameter.',
+      },
+      minimum_should_match: {
+        type: 'Int',
+        description: 'The minimum number of should clauses to match can be set using the minimum_should_match parameter.',
+      },
+      must_not: {
+        type: () => getQueryITC(opts),
+        description: 'The clause (query) must not appear in the matching documents. Clauses are executed in filter context meaning that scoring is ignored and clauses are considered for caching. Because scoring is ignored, a score of 0 for all documents is returned.',
+      },
+      boost: {
+        type: 'Float',
+      },
+    });
+
+    return BoolITC;
+  });
+}

src/ElasticDSL/Query/MatchAll.js

@@ -0,0 +1,20 @@
+/* @flow */
+
+import { InputTypeComposer } from 'graphql-compose';
+import { getTypeName, getOrSetType } from '../../utils';
+
+export function getMatchAllITC(opts = {}): InputTypeComposer {
+  const typeName = getTypeName('QueryMatchAll', opts);
+
+  return getOrSetType(typeName, () => {
+    const MatchAllITC = InputTypeComposer.create(typeName);
+    MatchAllITC.setDescription('The most simple query, which matches all documents, giving them all a _score of 1.0.');
+    MatchAllITC.setFields({
+      boost: {
+        type: 'Float',
+      },
+    });
+
+    return MatchAllITC;
+  });
+}

src/ElasticDSL/Query/Query.js

@@ -0,0 +1,32 @@
+/* @flow */
+
+import { InputTypeComposer } from 'graphql-compose';
+import { getBoolITC } from './Bool';
+import { getMatchAllITC } from './MatchAll';
+import { getTypeName, getOrSetType } from '../../utils';
+
+export function getQueryITC(opts = {}): InputTypeComposer {
+  const typeName = getTypeName('Query', opts);
+
+  return getOrSetType(typeName, () => {
+    const QueryITC = InputTypeComposer.create(typeName);
+    QueryITC.setFields({
+      bool: () => getBoolITC(opts),
+      match_all: () => getMatchAllITC(opts),
+      term: {
+        type: 'JSON',
+        description: 'The term query finds documents that contain the exact term specified in the inverted index. { fieldName: value } or { fieldName: { value: value, boost: 2.0 } }',
+      },
+      terms: {
+        type: 'JSON',
+        description: 'Filters documents that have fields that match any of the provided terms (not analyzed). { fieldName: [values] }',
+      },
+      match: {
+        type: 'JSON',
+        description: '',
+      },
+    });
+
+    return QueryITC;
+  });
+}

src/ElasticDSL/SearchBody.js

@@ -0,0 +1,21 @@
+/* @flow */
+
+import { InputTypeComposer } from 'graphql-compose';
+import { getQueryITC } from './Query/Query';
+import { getTypeName, getOrSetType } from '../utils';
+
+export function getSearchBodyITC(opts = {}): InputTypeComposer {
+  const typeName = getTypeName('SearchBody', opts);
+
+  return getOrSetType(typeName, () => {
+    const SearchBodyITC = InputTypeComposer.create(typeName);
+    SearchBodyITC.setDescription(
+      'A query that matches documents matching boolean combinations of other queries. The bool query maps to Lucene BooleanQuery. It is built using one or more boolean clauses, each clause with a typed occurrence. '
+    );
+    SearchBodyITC.setFields({
+      query: () => getQueryITC(opts),
+    });
+
+    return SearchBodyITC;
+  });
+}

src/__tests__/__snapshots__/ElasticApiParser-test.js.snap

@@ -33,7 +33,7 @@ Object {
         "type": "String",
       },
       "body": Object {
-        "type": "JSON",
+        "type": "ElasticSearchBody",
       },
       "defaultOperator": Object {
         "defaultValue": "OR",

src/__tests__/typeStorage-test.js

@@ -0,0 +1,47 @@
+/* @flow */
+
+import typeStorage from '../typeStorage';
+
+const GraphQLType = 'SomeTypeInstance';
+
+describe('typeStorage', () => {
+  beforeEach(() => {
+    typeStorage.clear();
+  });
+
+  it('should be instance of Map', () => {
+    expect(typeStorage).toBeInstanceOf(Map);
+  });
+
+  it('should work `get`, `set`, `has`, `clear` methods and `size` property', () => {
+    expect(typeStorage.size).toEqual(0);
+    typeStorage.set('MyType', GraphQLType);
+    expect(typeStorage.get('MyType')).toEqual(GraphQLType);
+    expect(typeStorage.has('MyType')).toEqual(true);
+    expect(typeStorage.size).toEqual(1);
+    typeStorage.clear();
+    expect(typeStorage.size).toEqual(0);
+  });
+
+  describe('getOrSet() method', () => {
+    it('should return existed value', () => {
+      typeStorage.set('MyType', GraphQLType);
+      expect(typeStorage.getOrSet('MyType', () => 'any')).toEqual(GraphQLType);
+    });
+
+    it('should set new type as function and return type, if key not exists', () => {
+      expect(typeStorage.getOrSet('MyType', () => GraphQLType)).toEqual(GraphQLType);
+      expect(typeStorage.get('MyType')).toEqual(GraphQLType);
+    });
+
+    it('should set new type and return it, if key not exists', () => {
+      expect(typeStorage.getOrSet('MyType', GraphQLType)).toEqual(GraphQLType);
+      expect(typeStorage.get('MyType')).toEqual(GraphQLType);
+    });
+
+    it('should not set new value if it is empty', () => {
+      expect(typeStorage.getOrSet('MyType', () => null)).toEqual(null);
+      expect(typeStorage.has('MyType')).toEqual(false);
+    });
+  });
+});

src/typeStorage.js

@@ -0,0 +1,33 @@
+/* @flow */
+import { isFunction } from 'graphql-compose';
+
+class TypeStorage extends Map {
+  // this `create` hack due TypeError:
+  // Constructor Map requires 'new' at TypeStorage.Map (native)
+  static create(array?:any[]): TypeStorage {
+    const inst = new Map(array);
+    // $FlowFixMe
+    inst.__proto__ = TypeStorage.prototype; // eslint-disable-line
+    // $FlowFixMe
+    return inst;
+  }
+
+  getOrSet<T>(typeName: string, typeOrThunk: T | () => T): ?T {
+    if (this.has(typeName)) {
+      // $FlowFixMe
+      return this.get(typeName);
+    }
+
+
+    // $FlowFixMe
+    const gqType: T = isFunction(typeOrThunk) ? typeOrThunk() : typeOrThunk;
+    if (gqType) {
+      this.set(typeName, gqType);
+    }
+
+    return gqType;
+  }
+}
+
+const typeStorage = TypeStorage.create();
+export default typeStorage;

src/utils.js

@@ -0,0 +1,9 @@
+import typeStorage from './typeStorage';
+
+export function getTypeName(name: string, opts: any): string {
+  return `${opts && opts.prefix || 'Elastic'}${name}${opts && opts.postfix || ''}`;
+}
+
+export function getOrSetType<T>(typeName: string, typeOrThunk: T | () => T): T {
+  return typeStorage.getOrSet(typeName, typeOrThunk);
+}