wip(SearchResolver): Describing Output, autofill some arguments due projection

Author: nodkz

examples/elastic50/index.js

@@ -8,7 +8,10 @@ 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';
+import {
+  inputPropertiesToGraphQLTypes,
+  convertToSourceTC,
+} from '../../src/mappingConverter';
 
 const expressPort = process.env.port || process.env.PORT || 9201;
 
@@ -19,7 +22,7 @@ const generatedSchema = new GraphQLSchema({
       // $FlowFixMe
       cv: createSearchResolver(
         inputPropertiesToGraphQLTypes(fieldMap),
-        undefined,
+        convertToSourceTC(fieldMap, 'Cv', { prefix: '' }),
         new elasticsearch.Client({
           host: 'http://localhost:9200',
           apiVersion: '5.0',

src/resolvers/__tests__/search-test.js

@@ -1,5 +1,5 @@
 import { Resolver } from 'graphql-compose';
-import createSearchResolver from '../search';
+import createSearchResolver, * as Search from '../search';
 import elasticClient from '../../__mocks__/elasticClient';
 import { CvTC, CvFieldMap } from '../../__mocks__/cv';
 
@@ -23,4 +23,13 @@ describe('search resolver', () => {
       });
     });
   });
+
+  describe('helper methods', () => {
+    it('toDottedList()', () => {
+      expect(
+        Search.toDottedList({ a: { b: true, c: { e: true } }, d: true })
+      ).toEqual(['a.b', 'a.c.e', 'd']);
+      expect(Search.toDottedList({})).toEqual(true);
+    });
+  });
 });

src/resolvers/search.js

@@ -1,15 +1,16 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
 
-import { Resolver, TypeComposer } from 'graphql-compose';
-import type { ResolveParams } from 'graphql-compose/lib/definition';
+import { Resolver, TypeComposer, isObject } from 'graphql-compose';
+import type { ResolveParams, ProjectionType } from 'graphql-compose/lib/definition';
 import type { FieldsMapByElasticType } from '../mappingConverter';
 import ElasticApiParser from '../ElasticApiParser';
 import type { ElasticApiVersion } from '../ElasticApiParser';
 import {
   getSearchBodyITC,
   prepareBodyInResolve,
 } from '../elasticDSL/SearchBody';
+import { getSearchOutputTC } from '../types/SearchOutput';
 
 export type ElasticSearchResolverOpts = {
   [name: string]: mixed,
@@ -19,7 +20,7 @@ export type ElasticSearchResolverOpts = {
 
 export default function createSearchResolver(
   fieldMap: FieldsMapByElasticType,
-  tc?: TypeComposer,
+  sourceTC?: TypeComposer,
   elasticClient?: mixed,
   opts?: ElasticSearchResolverOpts = {}
 ): Resolver<*, *> {
@@ -35,10 +36,12 @@ export default function createSearchResolver(
   //   );
   // }
 
+  const prefix = opts.prefix || 'Es';
+
   const parser = new ElasticApiParser({
     elasticClient,
     version: opts.elasticApiVersion || '5_0',
-    prefix: opts.prefix || 'Es',
+    prefix,
   });
   const searchFC = parser.generateFieldConfig('search', {
     index: 'cv',
@@ -48,26 +51,83 @@ export default function createSearchResolver(
   const args = Object.assign({}, searchFC.args, {
     body: {
       type: getSearchBodyITC({
-        prefix: opts.prefix,
+        prefix,
         fieldMap,
       }).getType(),
     },
   });
 
+  delete args.index; // index can not be changed, it hardcoded in searchFC
+  delete args.type; // type can not be changed, it hardcoded in searchFC
+  delete args.explain; // added automatically if requested _shard, _node, _explanation
+  delete args.version; // added automatically if requested _version
+  delete args._source; // added automatically due projection
+  delete args._sourceExclude; // added automatically due projection
+  delete args._sourceInclude; // added automatically due projection
+
   // $FlowFixMe
   return new Resolver({
-    type: 'JSON', // [tc],
+    // $FlowFixMe
+    type: sourceTC ? getSearchOutputTC({ prefix, fieldMap, sourceTC }) : 'JSON',
     name: 'search',
     kind: 'query',
     args,
     resolve: (rp: ResolveParams<*, *>) => {
       if (rp.args && rp.args.body) {
         rp.args.body = prepareBodyInResolve(rp.args.body, fieldMap);
       }
+
+      const { projection = {} } = rp;
+      const { hits = {} } = projection;
+      // $FlowFixMe
+      const { hits: hitsHits } = hits;
+
+      if (typeof hitsHits === 'object') {
+        // Turn on explain if in projection requested this fields:
+        if (hitsHits._shard || hitsHits._node || hitsHits._explanation) {
+          // $FlowFixMe
+          rp.args.body.explain = true;
+        }
+
+        if (hitsHits._version) {
+          // $FlowFixMe
+          rp.args.body.version = true;
+        }
+
+        if (!hitsHits._source) {
+          // $FlowFixMe
+          rp.args.body._source = false;
+        } else {
+          // $FlowFixMe
+          rp.args.body._source = toDottedList(hitsHits._source);
+        }
+      }
+
       // $FlowFixMe
       const res = searchFC.resolve(rp.source, rp.args, rp.context, rp.info);
-      // console.log(res);
+
       return res;
     },
   });
 }
+
+export function toDottedList(projection: ProjectionType, prev: string[]): string[] | boolean {
+  let result = [];
+  Object.keys(projection).forEach(k => {
+    if (isObject(projection[k])) {
+      // $FlowFixMe
+      const tmp = toDottedList(projection[k], prev ? [ ...prev, k] : [k]);
+      if (Array.isArray(tmp)) {
+        result = result.concat(tmp);
+        return;
+      }
+    }
+
+    if (prev) {
+      result.push([...prev, k].join('.'));
+    } else {
+      result.push(k);
+    }
+  });
+  return result.length > 0 ? result : true;
+}

src/types/SearchHitItem.js

@@ -0,0 +1,45 @@
+/* @flow */
+
+import { TypeComposer } from 'graphql-compose';
+import { getTypeName, getOrSetType, desc } from '../utils';
+import type { SearchOptsT } from './SearchOutput';
+
+export function getSearchHitItemTC(opts: SearchOptsT = {}): TypeComposer {
+  const name = getTypeName('SearchHitItem', opts);
+
+  return getOrSetType(name, () =>
+    // $FlowFixMe
+    TypeComposer.create({
+      name,
+      fields: {
+        _index: 'String',
+        _type: 'String',
+        _id: 'String',
+        _score: 'Float',
+        _source: opts.sourceTC || 'JSON',
+
+        // if arg.explain = true
+        _shard: {
+          type: 'String',
+          description: desc(`Use explain API on query`),
+        },
+        _node: {
+          type: 'String',
+          description: desc(`Use explain API on query`),
+        },
+        _explanation: {
+          type: 'JSON',
+          description: desc(`Use explain API on query`),
+        },
+
+        // if arg.version = true
+        _version: 'Int',
+
+        // if args.highlight is provided
+        highlight: 'JSON',
+
+        // return sort values for search_after
+        sort: 'JSON',
+      },
+    }));
+}

src/types/SearchOutput.js

@@ -0,0 +1,40 @@
+/* @flow */
+
+import { TypeComposer } from 'graphql-compose';
+import { getTypeName, getOrSetType, desc } from '../utils';
+import type { FieldsMapByElasticType } from '../mappingConverter';
+import getShardsTC from './Shards';
+import { getSearchHitItemTC } from './SearchHitItem';
+
+export type SearchOptsT = {
+  prefix?: string,
+  postfix?: string,
+  fieldMap?: FieldsMapByElasticType,
+  sourceTC?: TypeComposer,
+};
+
+export function getSearchOutputTC(opts: SearchOptsT = {}): TypeComposer {
+  const name = getTypeName('SearchOutput', opts);
+  const nameHits = getTypeName('SearchHits', opts);
+
+  return getOrSetType(name, () =>
+    // $FlowFixMe
+    TypeComposer.create({
+      name,
+      fields: {
+        took: 'Int',
+        timed_out: 'Boolean',
+        _shards: getShardsTC(opts),
+        hits: getOrSetType(nameHits, () =>
+          // $FlowFixMe
+          TypeComposer.create({
+            name: nameHits,
+            fields: {
+              total: 'Int',
+              max_score: 'Float',
+              hits: [getSearchHitItemTC(opts)],
+            },
+          })),
+      },
+    }));
+}

src/types/Shards.js

@@ -0,0 +1,17 @@
+import { TypeComposer } from 'graphql-compose';
+import { getTypeName, getOrSetType } from '../utils';
+
+export default function getShardsTC(opts: mixed = {}): TypeComposer {
+  const name = getTypeName('MetaShards', opts);
+
+  return getOrSetType(name, () =>
+    // $FlowFixMe
+    TypeComposer.create({
+      name,
+      fields: {
+        total: 'Int',
+        successful: 'Int',
+        failed: 'Int',
+      },
+    }));
+}