feat(Query): Queries now support fields from mapping

Author: nodkz

examples/elastic50/index.js

@@ -1,21 +1,40 @@
+/* @flow */
+/* eslint-disable no-console */
+
 import express from 'express';
 import graphqlHTTP from 'express-graphql';
 import { GraphQLSchema, GraphQLObjectType, GraphQLString } from 'graphql';
 import elasticsearch from 'elasticsearch';
 import ElasticApiParser from '../../src/ElasticApiParser'; // or import { ElasticApiParser } from 'graphql-compose-elasticsearch';
+import createSearchResolver from '../../src/resolvers/search';
+import fieldMap from '../../src/__mocks__/cvMapping';
+import { inputPropertiesToGraphQLTypes } from '../../src/mappingConverter';
 
 const expressPort = process.env.port || process.env.PORT || 9201;
 
 const generatedSchema = new GraphQLSchema({
   query: new GraphQLObjectType({
     name: 'Query',
     fields: {
+      // $FlowFixMe
+      cv: createSearchResolver(
+        inputPropertiesToGraphQLTypes(fieldMap),
+        undefined,
+        new elasticsearch.Client({
+          host: 'http://localhost:9200',
+          apiVersion: '5.0',
+          log: 'trace',
+        }),
+        {
+          prefix: 'Cv',
+        }
+      ).getFieldConfig(),
       // see node_modules/elasticsearch/src/lib/apis/ for available versions
-
       elastic50: {
         description: 'Elastic v5.0',
         type: new GraphQLObjectType({
           name: 'Elastic50',
+          // $FlowFixMe
           fields: new ElasticApiParser({
             version: '5_0',
             prefix: 'Elastic50',
@@ -28,12 +47,14 @@ const generatedSchema = new GraphQLSchema({
           },
         },
         resolve: (src, args, context) => {
-          // eslint-disable-next-line no-param-reassign
-          context.elasticClient = new elasticsearch.Client({
-            host: args.host,
-            apiVersion: '5.0',
-            log: 'trace',
-          });
+          if (typeof context === 'object') {
+            // eslint-disable-next-line no-param-reassign
+            context.elasticClient = new elasticsearch.Client({
+              host: args.host,
+              apiVersion: '5.0',
+              log: 'trace',
+            });
+          }
           return {};
         },
       },

src/ElasticApiParser.js

@@ -239,7 +239,7 @@ export default class ElasticApiParser {
 
   generateFieldConfig(
     methodName: string,
-    methodArgs: { [paramName: string]: mixed }
+    methodArgs?: { [paramName: string]: mixed }
   ): GraphQLFieldConfig<*, *> {
     if (!methodName) {
       throw new Error(`You should provide Elastic search method.`);

src/__mocks__/cvMapping.js

@@ -321,6 +321,9 @@ export default {
             },
           },
         },
+        location: {
+          type: 'geo_point',
+        },
       },
     },
     middlename: {

src/composeWithElastic.js

@@ -1,4 +1,4 @@
-import { TypeComposer, InputTypeComposer } from 'graphql-compose';
+import { TypeComposer } from 'graphql-compose';
 import {
   convertToSourceTC,
   inputPropertiesToGraphQLTypes,

src/elasticDSL/Aggs/converter.js renamed to src/elasticDSL/Aggs/Aggs.js

@@ -1,3 +1,9 @@
+import { getAggBlockITC } from './AggBlock';
+
+export function getAggsITC(opts: mixed) {
+  return [getAggBlockITC(opts)];
+}
+
 export type ElasticAggsT = {
   [outputFieldName: string]: ElasticAggsRulesT,
 };
@@ -14,17 +20,17 @@ export type GqlAggBlock = {
 
 export type GqlAggRules = {
   [aggOperationName: string]: mixed,
-  aggs: GqlAggBlock,
+  aggs: GqlAggBlock[],
 };
 
-export default function argsBlockConverter(
-  args: { [argName: string]: any }
+export function prepareAggsInResolve(
+  aggs: GqlAggBlock[],
+  fieldMap: any // eslint-disable-line
 ): { [argName: string]: any } {
-  if (args && args.body && Array.isArray(args.body.aggs)) {
-    const aggs: GqlAggBlock[] = args.body.aggs;
-    args.body.aggs = convertAggsBlocks(aggs); // eslint-disable-line
+  if (Array.isArray(aggs)) {
+    return convertAggsBlocks(aggs);
   }
-  return args;
+  return aggs;
 }
 
 export function convertAggsBlocks(blockList: GqlAggBlock[]): ElasticAggsT {
@@ -43,6 +49,7 @@ export function convertAggsRules(rules: GqlAggRules): ElasticAggsRulesT {
     if (key === 'aggs' && rules.aggs) {
       result.aggs = convertAggsBlocks(rules.aggs);
     } else {
+      // $FlowFixMe
       result[key] = rules[key];
     }
   });

src/elasticDSL/Aggs/__tests__/Aggs-test.js

@@ -0,0 +1,78 @@
+/* @flow */
+
+import {
+  printSchema,
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLInt,
+} from 'graphql';
+import { TypeMapper } from 'graphql-compose';
+import {
+  getAggsITC,
+  prepareAggsInResolve,
+  convertAggsBlocks,
+  convertAggsRules,
+} from '../Aggs';
+
+describe('AGGS args converter', () => {
+  it('Aggs DSL', () => {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'RootQuery',
+        fields: {
+          search: {
+            // $FlowFixMe
+            args: TypeMapper.convertArgConfigMap({
+              body: {
+                type: getAggsITC({
+                  prefix: 'Elastic_',
+                  postfix: '_50',
+                }),
+              },
+            }),
+            type: GraphQLInt,
+          },
+        },
+      }),
+    });
+    expect(printSchema(schema)).toMatchSnapshot();
+  });
+
+  it('convertAggsRules()', () => {
+    expect(convertAggsRules({ some: { field: 1 } })).toEqual({
+      some: { field: 1 },
+    });
+  });
+
+  it('convertAggsBlocks()', () => {
+    expect(
+      convertAggsBlocks([
+        { key: 'field1', value: {} },
+        { key: 'field2', value: {} },
+      ])
+    ).toEqual({
+      field1: {},
+      field2: {},
+    });
+  });
+
+  it('should convert recursively aggs', () => {
+    expect(
+      convertAggsBlocks([
+        { key: 'field1', value: { aggs: [{ key: 'field2', value: {} }] } },
+      ])
+    ).toEqual({ field1: { aggs: { field2: {} } } });
+  });
+
+  it('prepareAggsInResolve()', () => {
+    expect(
+      prepareAggsInResolve([
+        { key: 'field1', value: { term: 'a' } },
+        { key: 'field2', value: { term: 'b' } },
+      ])
+    ).toEqual({
+      field1: { term: 'a' },
+      field2: { term: 'b' },
+    });
+  });
+});