wip: Simplify input args and output for search and searchConnection resolvers

Author: nodkz

examples/elastic50/index.js

@@ -84,6 +84,10 @@ server.use(
       //   log: 'trace',
       // }),
     },
+    formatError: error => ({
+      message: error.message,
+      stack: error.stack.split('\n'),
+    }),
   })
 );
 

src/resolvers/search.js

@@ -1,8 +1,16 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
 
-import { Resolver, TypeComposer, isObject } from 'graphql-compose';
-import type { ResolveParams, ProjectionType } from 'graphql-compose/lib/definition';
+import {
+  Resolver,
+  TypeComposer,
+  InputTypeComposer,
+  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';
@@ -20,7 +28,7 @@ export type ElasticSearchResolverOpts = {
 
 export default function createSearchResolver(
   fieldMap: FieldsMapByElasticType,
-  sourceTC?: TypeComposer,
+  sourceTC: TypeComposer,
   elasticClient?: mixed,
   opts?: ElasticSearchResolverOpts = {}
 ): Resolver<*, *> {
@@ -43,10 +51,6 @@ export default function createSearchResolver(
     version: opts.elasticApiVersion || '5_0',
     prefix,
   });
-  const searchFC = parser.generateFieldConfig('search', {
-    index: 'cv',
-    type: 'cv',
-  });
 
   const searchITC = getSearchBodyITC({
     prefix,
@@ -55,6 +59,11 @@ export default function createSearchResolver(
 
   searchITC.removeField(['size', 'from', '_source', 'explain', 'version']);
 
+  const searchFC = parser.generateFieldConfig('search', {
+    index: 'cv',
+    type: 'cv',
+  });
+
   const argsConfigMap = Object.assign({}, searchFC.args, {
     body: {
       type: searchITC.getType(),
@@ -68,31 +77,69 @@ export default function createSearchResolver(
   delete argsConfigMap._source; // added automatically due projection
   delete argsConfigMap._sourceExclude; // added automatically due projection
   delete argsConfigMap._sourceInclude; // added automatically due projection
+  delete argsConfigMap.trackScores; // added automatically due projection (is _scrore requested with sort)
 
   delete argsConfigMap.size;
   delete argsConfigMap.from;
+  // $FlowFixMe
   argsConfigMap.limit = 'Int';
+  // $FlowFixMe
   argsConfigMap.skip = 'Int';
 
-  const type = getSearchOutputTC({ prefix, fieldMap, sourceTC });
-  // $FlowFixMe
-  type.addFields({
-    count: 'Int',
-    max_score: 'Float',
+  const bodyITC = InputTypeComposer.create(argsConfigMap.body.type);
+  argsConfigMap.query = bodyITC.getField('query');
+  argsConfigMap.aggs = bodyITC.getField('aggs');
+  argsConfigMap.highlight = bodyITC.getField('highlight');
+
+  const topLevelArgs = [
+    'limit',
+    'skip',
+    'q',
+    'opts',
+    'query',
+    'aggs',
+    'highlight',
+  ];
+  argsConfigMap.opts = InputTypeComposer.create({
+    name: `${sourceTC.getTypeName()}Opts`,
+    fields: Object.assign({}, argsConfigMap),
+  }).removeField(topLevelArgs);
+  Object.keys(argsConfigMap).forEach(argKey => {
+    if (!topLevelArgs.includes(argKey)) {
+      delete argsConfigMap[argKey];
+    }
   });
 
+  const type = getSearchOutputTC({ prefix, fieldMap, sourceTC });
+  type
+    .addFields({
+      // $FlowFixMe
+      count: 'Int',
+      // $FlowFixMe
+      max_score: 'Float',
+      // $FlowFixMe
+      hits: [type.get('hits.hits')],
+    })
+    .reorderFields([
+      'hits',
+      'count',
+      'aggregations',
+      'max_score',
+      'took',
+      'timed_out',
+      '_shards',
+    ]);
+
   // $FlowFixMe
   return new Resolver({
     type,
     name: 'search',
     kind: 'query',
     args: argsConfigMap,
     resolve: async (rp: ResolveParams<*, *>) => {
-      const { args = {}, projection = {} } = rp;
-
-      if (args.body) {
-        args.body = prepareBodyInResolve(args.body, fieldMap);
-      }
+      let args: Object = rp.args || {};
+      const projection = rp.projection || {};
+      if (!args.body) args.body = {};
 
       if ({}.hasOwnProperty.call(args, 'limit')) {
         args.size = args.limit;
@@ -105,47 +152,78 @@ export default function createSearchResolver(
       }
 
       const { hits = {} } = projection;
-      // $FlowFixMe
-      const { hits: hitsHits } = hits;
 
-      if (typeof hitsHits === 'object') {
+      if (typeof hits === 'object') {
         // Turn on explain if in projection requested this fields:
-        if (hitsHits._shard || hitsHits._node || hitsHits._explanation) {
-          // $FlowFixMe
+        if (hits._shard || hits._node || hits._explanation) {
           args.body.explain = true;
         }
 
-        if (hitsHits._version) {
-          // $FlowFixMe
+        if (hits._version) {
           args.body.version = true;
         }
 
-        if (!hitsHits._source) {
-          // $FlowFixMe
+        if (!hits._source) {
           args.body._source = false;
         } else {
           // $FlowFixMe
-          args.body._source = toDottedList(hitsHits._source);
+          args.body._source = toDottedList(hits._source);
         }
+
+        if (hits._score) {
+          args.body.track_scores = true;
+        }
+      }
+
+      if (args.query) {
+        args.body.query = args.query;
+        delete args.query;
+      }
+
+      if (args.aggs) {
+        args.body.aggs = args.aggs;
+        delete args.aggs;
+      }
+
+      if (args.opts) {
+        args = {
+          ...args.opts,
+          ...args,
+          body: { ...args.opts.body, ...args.body },
+        };
+        delete args.opts;
+      }
+
+      if (args.body) {
+        args.body = prepareBodyInResolve(args.body, fieldMap);
       }
 
       // $FlowFixMe
-      const res = await searchFC.resolve(rp.source, args, rp.context, rp.info);
+      const res: any = await searchFC.resolve(
+        rp.source,
+        args,
+        rp.context,
+        rp.info
+      );
 
       res.count = res.hits.total;
       res.max_score = res.hits.max_score;
+      res.hits = res.hits.hits;
 
       return res;
     },
-  });
+  }).reorderArgs(['q', 'query', 'aggs', 'limit', 'skip']);
 }
 
-export function toDottedList(projection: ProjectionType, prev: string[]): string[] | boolean {
+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]);
+      const tmp = toDottedList(projection[k], prev ? [...prev, k] : [k]);
       if (Array.isArray(tmp)) {
         result = result.concat(tmp);
         return;

src/resolvers/searchConnection.js

@@ -1,6 +1,6 @@
 /* @Flow */
 
-import { Resolver, TypeComposer, isObject } from 'graphql-compose';
+import { Resolver, TypeComposer } from 'graphql-compose';
 import { getTypeName, getOrSetType } from '../utils';
 
 export default function createSearchConnectionResolver(
@@ -11,32 +11,36 @@ export default function createSearchConnectionResolver(
     name: `${searchResolver.name}Connection`,
   });
 
-  resolver.addArgs({
-    first: 'Int',
-    after: 'String',
-    last: 'Int',
-    before: 'String',
-  });
-  resolver.removeArg('limit');
-  resolver.removeArg('skip');
+  resolver
+    .addArgs({
+      first: 'Int',
+      after: 'String',
+      last: 'Int',
+      before: 'String',
+    })
+    .removeArg(['limit', 'skip'])
+    .reorderArgs(['q', 'query', 'aggs', 'first', 'after', 'last', 'before']);
 
   const searchType = searchResolver.getTypeComposer();
   const typeName = searchType.getTypeName();
-  const type = searchType.clone(`${typeName}Connection`);
-  type.addFields({
-    pageInfo: getPageInfoTC(opts),
-    edges: [
-      TypeComposer.create({
-        name: `${typeName}Edge`,
-        fields: {
-          node: searchType.get('hits.hits'),
-          cursor: 'String!',
-        },
-      }),
-    ],
-  });
-  type.removeField('hits');
-  resolver.setType(type);
+  resolver.setType(
+    searchType
+      .clone(`${typeName}Connection`)
+      .addFields({
+        pageInfo: getPageInfoTC(opts),
+        edges: [
+          TypeComposer.create({
+            name: `${typeName}Edge`,
+            fields: {
+              node: searchType.get('hits'),
+              cursor: 'String!',
+            },
+          }),
+        ],
+      })
+      .removeField('hits')
+      .reorderFields(['count', 'pageInfo', 'edges', 'aggregations'])
+  );
 
   resolver.resolve = async rp => {
     const { args = {} } = rp;
@@ -49,21 +53,43 @@ export default function createSearchConnectionResolver(
     if (last < 0) {
       throw new Error('Argument `last` should be non-negative number.');
     }
+    const { before, after } = args;
+    delete args.before;
+    delete args.after;
+    if (before !== undefined) {
+      throw new Error('Elastic does not support before cursor.');
+    }
+    if (after) {
+      if (!args.body) args.body = {};
+      const tmp = cursorToData(after);
+      if (Array.isArray(tmp)) {
+        args.body.search_after = tmp;
+      }
+    }
 
-    let limit = last || first || 20;
-    let skip = last > 0 ? first - last : 0;
+    const limit = last || first || 20;
+    const skip = last > 0 ? first - last : 0;
 
-    delete rp.args.last;
-    delete rp.args.first;
-    rp.args.limit = limit;
-    rp.args.skip = skip;
+    delete args.last;
+    delete args.first;
+    args.limit = limit + 1; // +1 document, to check next page presence
+    args.skip = skip;
 
     const res = await searchResolver.resolve(rp);
-    const list = res.hits.hits;
+
+    let list = res.hits.hits;
+    const hasExtraRecords = list.length > limit;
+    if (hasExtraRecords) list = list.slice(0, limit);
+    const edges = list.map(node => ({ node, cursor: dataToCursor(node.sort) }));
     const result = {
       ...res,
-      pageInfo: {},  // TODO <------------------
-      edges: list.map(node => ({ node, cursor: dataToCursor(node.sort) })),
+      pageInfo: {
+        hasNextPage: limit > 0 && hasExtraRecords,
+        hasPreviousPage: false, // Elastic does not support before cursor
+        startCursor: edges.length > 0 ? edges[0].cursor : null,
+        endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null,
+      },
+      edges,
     };
 
     return result;
@@ -116,5 +142,6 @@ export function cursorToData(cursor: string): mixed {
 }
 
 export function dataToCursor(data: mixed): string {
+  if (!data) return '';
   return base64(JSON.stringify(data));
 }

src/types/SearchOutput.js

@@ -35,6 +35,7 @@ export function getSearchOutputTC(opts: SearchOptsT = {}): TypeComposer {
               hits: [getSearchHitItemTC(opts)],
             },
           })),
+        aggregations: 'JSON',
       },
     }));
 }