wip(composeWithElastic): Started work under TypeComposer generator from mapping

Author: nodkz

src/ElasticApiParser.js

@@ -102,6 +102,7 @@ export default class ElasticApiParser {
       const searchTyped = {
         type,
         description,
+        // $FlowFixMe
         resolve: prepareSearchArgs(resolve),
         // $FlowFixMe
         args: Object.assign({}, args, {
@@ -284,9 +285,9 @@ export default class ElasticApiParser {
         // eg '@param {anything} params.operationThreading - ?'
         return GraphQLJSON;
       default:
-        console.log(
+        console.log( // eslint-disable-line
           `New type '${paramCfg.type}' in elastic params setting for field ${fieldName}.`
-        ); // eslint-disable-line
+        );
         return GraphQLJSON;
     }
   }

src/ElasticDSL/SearchBody.js

@@ -11,9 +11,7 @@ export function getSearchBodyITC(opts: mixed = {}): InputTypeComposer {
   const name = getTypeName('SearchBody', opts);
   const description = desc(
     `
-    The search request can be executed with a search DSL, which includes
-    the [Query DSL](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html),
-    within its body.
+    [Request Body Search](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-body.html),
   `
   );
 
@@ -26,6 +24,23 @@ export function getSearchBodyITC(opts: mixed = {}): InputTypeComposer {
         query: () => getQueryITC(opts),
         aggs: () => [getAggBlockITC(opts)],
         size: 'Int',
+        from: 'Int',
+        sort: 'JSON',
+        _source: 'JSON',
+        script_fields: 'JSON',
+        post_filter: () => getQueryITC(opts),
+        highlight: 'JSON',
+        search_after: 'JSON',
+
+        explain: 'Boolean',
+        version: 'Boolean',
+        indices_boost: 'JSON',
+        min_score: 'Float',
+
+        search_type: 'String',
+        rescore: 'JSON',
+        docvalue_fields: '[String]',
+        stored_fields: '[String]',
       },
     }));
 }

src/__mocks__/cvMap.js renamed to src/__mocks__/cvMapping.js

@@ -359,6 +359,7 @@ describe('ElasticApiParser', () => {
   describe('reassembleNestedFields()', () => {
     it('should pass single fields', () => {
       expect(
+        // $FlowFixMe
         parser.reassembleNestedFields({
           field1: { type: GraphQLString },
           field2: { type: GraphQLString },
@@ -370,6 +371,7 @@ describe('ElasticApiParser', () => {
     });
 
     it('should combine nested field in GraphQLObjectType', () => {
+      // $FlowFixMe
       const reFields = parser.reassembleNestedFields({
         'cat.prototype.field1': { type: GraphQLString },
         'cat.prototype.field2': { type: GraphQLString },

src/__tests__/ElasticApiParser-test.js

@@ -13,12 +13,13 @@ import {
 
 import {
   convertToSourceTC,
-  propertyToGraphQLType,
+  propertyToSourceGraphQLType,
   convertToAggregatableITC,
   inputPropertiesToGraphQLTypes,
   convertToSearchableITC,
   convertToAnalyzedITC,
-} from '../PropertiesConverter';
+  getSubFields,
+} from '../mappingConverter';
 
 const mapping = {
   properties: {
@@ -84,54 +85,69 @@ describe('PropertiesConverter', () => {
     });
 
     it('should make singular and plural fields', () => {
-      const tc = convertToSourceTC(mapping, 'TestMapping');
-      const singular: any = tc.getField('name');
+      const tc1 = convertToSourceTC(mapping, 'TestMapping');
+      const singular: any = tc1.getField('name');
       expect(singular.type).toBe(GraphQLString);
 
-      const plural: any = tc.getField('nameA');
+      const tc2 = convertToSourceTC(mapping, 'TestMapping', {
+        pluralFields: ['name'],
+      });
+      const plural: any = tc2.getField('name');
       expect(plural.type).toBeInstanceOf(GraphQLList);
       expect(plural.type.ofType).toBe(GraphQLString);
     });
   });
 
-  describe('propertyToGraphQLType()', () => {
+  describe('propertyToSourceGraphQLType()', () => {
     it('should throw error on wrong property config', () => {
       expect(() => {
         // $FlowFixMe
-        propertyToGraphQLType();
+        propertyToSourceGraphQLType();
       }).toThrowError('incorrect Elastic property config');
       expect(() => {
-        propertyToGraphQLType({});
+        propertyToSourceGraphQLType({});
       }).toThrowError('incorrect Elastic property config');
     });
 
     it('should return GraphQLJSON as fallback for unknown Elastic type', () => {
-      expect(propertyToGraphQLType({ type: 'strange' })).toEqual(GraphQLJSON);
+      expect(propertyToSourceGraphQLType({ type: 'strange' })).toEqual(
+        GraphQLJSON
+      );
     });
 
     it('should return GraphQLInt for int types', () => {
-      expect(propertyToGraphQLType({ type: 'integer' })).toEqual(GraphQLInt);
-      expect(propertyToGraphQLType({ type: 'long' })).toEqual(GraphQLInt);
+      expect(propertyToSourceGraphQLType({ type: 'integer' })).toEqual(
+        GraphQLInt
+      );
+      expect(propertyToSourceGraphQLType({ type: 'long' })).toEqual(GraphQLInt);
     });
 
     it('should return GraphQLString for string types', () => {
-      expect(propertyToGraphQLType({ type: 'text' })).toEqual(GraphQLString);
-      expect(propertyToGraphQLType({ type: 'keyword' })).toEqual(GraphQLString);
+      expect(propertyToSourceGraphQLType({ type: 'text' })).toEqual(
+        GraphQLString
+      );
+      expect(propertyToSourceGraphQLType({ type: 'keyword' })).toEqual(
+        GraphQLString
+      );
     });
 
     it('should return GraphQLFloat for float types', () => {
-      expect(propertyToGraphQLType({ type: 'float' })).toEqual(GraphQLFloat);
-      expect(propertyToGraphQLType({ type: 'double' })).toEqual(GraphQLFloat);
+      expect(propertyToSourceGraphQLType({ type: 'float' })).toEqual(
+        GraphQLFloat
+      );
+      expect(propertyToSourceGraphQLType({ type: 'double' })).toEqual(
+        GraphQLFloat
+      );
     });
 
     it('should return GraphQLBoolean for float types', () => {
-      expect(propertyToGraphQLType({ type: 'boolean' })).toEqual(
+      expect(propertyToSourceGraphQLType({ type: 'boolean' })).toEqual(
         GraphQLBoolean
       );
     });
 
     it('should return GraphQLObjectType for object with subfields', () => {
-      const type = propertyToGraphQLType(
+      const type = propertyToSourceGraphQLType(
         {
           properties: {
             big: {
@@ -169,12 +185,13 @@ describe('PropertiesConverter', () => {
         () => true,
         'lastname'
       );
-      expect(fields.lastname).toEqual(GraphQLString);
+      expect(fields._all.lastname).toEqual(GraphQLString);
+      expect(fields.text.lastname).toEqual(GraphQLString);
     });
 
     it('should accept mapping', () => {
       const fields = inputPropertiesToGraphQLTypes(mapping, () => true);
-      expect(Object.keys(fields).length).toBeGreaterThan(2);
+      expect(Object.keys(fields._all).length).toBeGreaterThan(2);
     });
 
     it('should convert nested fields', () => {
@@ -194,10 +211,16 @@ describe('PropertiesConverter', () => {
         },
         () => true
       );
-      expect(Object.keys(fields).length).toEqual(2);
-      expect(Object.keys(fields)).toEqual(
+      expect(Object.keys(fields._all).length).toEqual(2);
+      expect(Object.keys(fields._all)).toEqual(
         expect.arrayContaining(['name', 'name__keyword'])
       );
+      expect(Object.keys(fields.keyword)).toEqual(
+        expect.arrayContaining(['name__keyword'])
+      );
+      expect(Object.keys(fields.text)).toEqual(
+        expect.arrayContaining(['name'])
+      );
     });
 
     it('should use filterFn', () => {
@@ -217,14 +240,18 @@ describe('PropertiesConverter', () => {
         },
         prop => prop.type !== 'text'
       );
-      expect(Object.keys(fields).length).toEqual(1);
-      expect(Object.keys(fields)).toEqual(
+      expect(Object.keys(fields._all).length).toEqual(1);
+      expect(Object.keys(fields._all)).toEqual(
+        expect.arrayContaining(['name__keyword'])
+      );
+      expect(Object.keys(fields.keyword).length).toEqual(1);
+      expect(Object.keys(fields.keyword)).toEqual(
         expect.arrayContaining(['name__keyword'])
       );
     });
 
     it('should not return index:false fields', () => {
-      const itc = convertToSearchableITC(mapping, 'SerachInput');
+      const itc = convertToSearchableITC(mapping, 'SearchInput');
       expect(itc.getFieldNames()).not.toEqual(
         expect.arrayContaining(['noIndex'])
       );
@@ -243,8 +270,12 @@ describe('PropertiesConverter', () => {
         },
         prop => prop.type !== 'text'
       );
-      expect(Object.keys(fields).length).toEqual(1);
-      expect(Object.keys(fields)).toEqual(
+      expect(Object.keys(fields._all).length).toEqual(1);
+      expect(Object.keys(fields._all)).toEqual(
+        expect.arrayContaining(['date'])
+      );
+      expect(Object.keys(fields.date).length).toEqual(1);
+      expect(Object.keys(fields.date)).toEqual(
         expect.arrayContaining(['date'])
       );
     });
@@ -305,14 +336,14 @@ describe('PropertiesConverter', () => {
     });
 
     it('should return InputTypeComposer', () => {
-      const itc = convertToSearchableITC(mapping, 'SerachInput');
+      const itc = convertToSearchableITC(mapping, 'SearchInput');
       expect(itc).toBeInstanceOf(InputTypeComposer);
-      expect(itc.getTypeName()).toBe('SerachInput');
+      expect(itc.getTypeName()).toBe('SearchInput');
       expect(itc.getFieldNames().length).toBeGreaterThan(1);
     });
 
     it('should return array of searchable fields', () => {
-      const itc = convertToSearchableITC(mapping, 'SerachInput');
+      const itc = convertToSearchableITC(mapping, 'SearchInput');
       expect(itc.getFieldNames()).toEqual(
         expect.arrayContaining([
           'name__keyword',
@@ -327,7 +358,6 @@ describe('PropertiesConverter', () => {
     });
   });
 
-
   describe('convertToAnalyzedITC()', () => {
     it('should throw error on empty mapping', () => {
       // $FlowFixMe
@@ -360,4 +390,17 @@ describe('PropertiesConverter', () => {
       );
     });
   });
+
+  describe('getSubFields()', () => {
+    it('should return array of sub fields', () => {
+      expect(
+        getSubFields('range', ['ok', 'range', 'range.min', 'range.max'])
+      ).toEqual(['min', 'max']);
+    });
+
+    it('should return array for empty/undefined list', () => {
+      expect(getSubFields('range', null)).toEqual([]);
+      expect(getSubFields('range')).toEqual([]);
+    });
+  });
 });

src/__tests__/PropertiesConverter-test.js renamed to src/__tests__/mappingConverter-test.js

@@ -30,7 +30,9 @@ describe('typeStorage', () => {
     });
 
     it('should set new type as function and return type, if key not exists', () => {
-      expect(typeStorage.getOrSet('MyType', () => GraphQLType)).toEqual(GraphQLType);
+      expect(typeStorage.getOrSet('MyType', () => GraphQLType)).toEqual(
+        GraphQLType
+      );
       expect(typeStorage.get('MyType')).toEqual(GraphQLType);
     });
 

src/__tests__/query-test.js

@@ -0,0 +1,39 @@
+import { TypeComposer, InputTypeComposer } from 'graphql-compose';
+import {
+  convertToSourceTC,
+  inputPropertiesToGraphQLTypes,
+} from './mappingConverter';
+import type { ElasticMappingT } from './mappingConverter';
+
+export type composeWithElasticOptsT = {
+  typeName: string,
+  pluralFields?: string[],
+};
+
+export function composeWithElastic(
+  mapping: ElasticMappingT,
+  opts: composeWithElasticOptsT = {}
+): TypeComposer {
+  if (!opts) {
+    throw new Error('Opts is required argument for composeWithElastic()');
+  }
+
+  if (typeof opts.typeName !== 'string' || !opts.typeName) {
+    throw new Error(
+      'Opts.typeName is required option for TypeName in composeWithElastic()'
+    );
+  }
+
+  if (opts.pluralFields && !Array.isArray(opts.pluralFields)) {
+    throw new Error(
+      'Opts.pluralFields should be an Array of strings with field names ' +
+        'which are plural (you may use dot notation for nested fields).'
+    );
+  }
+
+  const tc = convertToSourceTC(mapping, opts.typeName, opts);
+
+  const propsMap = inputPropertiesToGraphQLTypes(mapping);
+
+  return tc;
+}