wip(SearchConnection): Create SearchConnectionResolver wrapper on SearchResolver

Author: nodkz

examples/elastic50/index.js

@@ -7,6 +7,8 @@ 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 createSearchConnectionResolver
+  from '../../src/resolvers/searchConnection';
 import fieldMap from '../../src/__mocks__/cvMapping';
 import {
   inputPropertiesToGraphQLTypes,
@@ -15,23 +17,27 @@ import {
 
 const expressPort = process.env.port || process.env.PORT || 9201;
 
+const cvSearch = createSearchResolver(
+  inputPropertiesToGraphQLTypes(fieldMap),
+  convertToSourceTC(fieldMap, 'Cv', { prefix: '' }),
+  new elasticsearch.Client({
+    host: 'http://localhost:9200',
+    apiVersion: '5.0',
+    log: 'trace',
+  }),
+  {
+    prefix: 'Cv',
+  }
+);
+const cvSearchConnection = createSearchConnectionResolver(cvSearch);
+
 const generatedSchema = new GraphQLSchema({
   query: new GraphQLObjectType({
     name: 'Query',
     fields: {
       // $FlowFixMe
-      cv: createSearchResolver(
-        inputPropertiesToGraphQLTypes(fieldMap),
-        convertToSourceTC(fieldMap, 'Cv', { prefix: '' }),
-        new elasticsearch.Client({
-          host: 'http://localhost:9200',
-          apiVersion: '5.0',
-          log: 'trace',
-        }),
-        {
-          prefix: 'Cv',
-        }
-      ).getFieldConfig(),
+      cv: cvSearch.getFieldConfig(),
+      cvConnection: cvSearchConnection.getFieldConfig(),
       // see node_modules/elasticsearch/src/lib/apis/ for available versions
       elastic50: {
         description: 'Elastic v5.0',

package.json

@@ -38,17 +38,17 @@
     "babel-preset-env": "^1.2.2",
     "cz-conventional-changelog": "^2.0.0",
     "elasticsearch": "^12.1.3",
-    "eslint": "^3.17.1",
+    "eslint": "^3.18.0",
     "eslint-config-airbnb-base": "^11.0.1",
     "eslint-config-prettier": "^1.0.2",
     "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",
+    "flow-bin": "^0.42.0",
     "graphql": "^0.9.1",
-    "graphql-compose": "^1.17.2",
+    "graphql-compose": "^1.17.3",
     "jest": "^19.0.2",
     "jest-babel": "^1.0.1",
     "npm-run-all": "^4.0.1",

src/resolvers/search.js

@@ -30,11 +30,11 @@ export default function createSearchResolver(
     );
   }
 
-  // if (!(tc instanceof TypeComposer)) {
-  //   throw new Error(
-  //     'Second arg for Resolver search() should be instance of TypeComposer.'
-  //   );
-  // }
+  if (!(sourceTC instanceof TypeComposer)) {
+    throw new Error(
+      'Second arg for Resolver search() should be instance of TypeComposer.'
+    );
+  }
 
   const prefix = opts.prefix || 'Es';
 
@@ -48,36 +48,62 @@ export default function createSearchResolver(
     type: 'cv',
   });
 
-  const args = Object.assign({}, searchFC.args, {
+  const searchITC = getSearchBodyITC({
+    prefix,
+    fieldMap,
+  });
+
+  searchITC.removeField(['size', 'from', '_source', 'explain', 'version']);
+
+  const argsConfigMap = Object.assign({}, searchFC.args, {
     body: {
-      type: getSearchBodyITC({
-        prefix,
-        fieldMap,
-      }).getType(),
+      type: searchITC.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
+  delete argsConfigMap.index; // index can not be changed, it hardcoded in searchFC
+  delete argsConfigMap.type; // type can not be changed, it hardcoded in searchFC
+  delete argsConfigMap.explain; // added automatically if requested _shard, _node, _explanation
+  delete argsConfigMap.version; // added automatically if requested _version
+  delete argsConfigMap._source; // added automatically due projection
+  delete argsConfigMap._sourceExclude; // added automatically due projection
+  delete argsConfigMap._sourceInclude; // added automatically due projection
+
+  delete argsConfigMap.size;
+  delete argsConfigMap.from;
+  argsConfigMap.limit = 'Int';
+  argsConfigMap.skip = 'Int';
+
+  const type = getSearchOutputTC({ prefix, fieldMap, sourceTC });
+  // $FlowFixMe
+  type.addFields({
+    count: 'Int',
+    max_score: 'Float',
+  });
 
   // $FlowFixMe
   return new Resolver({
-    // $FlowFixMe
-    type: sourceTC ? getSearchOutputTC({ prefix, fieldMap, sourceTC }) : 'JSON',
+    type,
     name: 'search',
     kind: 'query',
-    args,
-    resolve: (rp: ResolveParams<*, *>) => {
-      if (rp.args && rp.args.body) {
-        rp.args.body = prepareBodyInResolve(rp.args.body, fieldMap);
+    args: argsConfigMap,
+    resolve: async (rp: ResolveParams<*, *>) => {
+      const { args = {}, projection = {} } = rp;
+
+      if (args.body) {
+        args.body = prepareBodyInResolve(args.body, fieldMap);
+      }
+
+      if ({}.hasOwnProperty.call(args, 'limit')) {
+        args.size = args.limit;
+        delete args.limit;
+      }
+
+      if ({}.hasOwnProperty.call(args, 'skip')) {
+        args.from = args.skip;
+        delete args.skip;
       }
 
-      const { projection = {} } = rp;
       const { hits = {} } = projection;
       // $FlowFixMe
       const { hits: hitsHits } = hits;
@@ -86,25 +112,28 @@ export default function createSearchResolver(
         // Turn on explain if in projection requested this fields:
         if (hitsHits._shard || hitsHits._node || hitsHits._explanation) {
           // $FlowFixMe
-          rp.args.body.explain = true;
+          args.body.explain = true;
         }
 
         if (hitsHits._version) {
           // $FlowFixMe
-          rp.args.body.version = true;
+          args.body.version = true;
         }
 
         if (!hitsHits._source) {
           // $FlowFixMe
-          rp.args.body._source = false;
+          args.body._source = false;
         } else {
           // $FlowFixMe
-          rp.args.body._source = toDottedList(hitsHits._source);
+          args.body._source = toDottedList(hitsHits._source);
         }
       }
 
       // $FlowFixMe
-      const res = searchFC.resolve(rp.source, rp.args, rp.context, rp.info);
+      const res = await searchFC.resolve(rp.source, args, rp.context, rp.info);
+
+      res.count = res.hits.total;
+      res.max_score = res.hits.max_score;
 
       return res;
     },

src/resolvers/searchConnection.js

@@ -0,0 +1,120 @@
+/* @Flow */
+
+import { Resolver, TypeComposer, isObject } from 'graphql-compose';
+import { getTypeName, getOrSetType } from '../utils';
+
+export default function createSearchConnectionResolver(
+  searchResolver: Resolver<*, *>,
+  opts: mixed = {}
+): Resolver<*, *> {
+  const resolver = searchResolver.clone({
+    name: `${searchResolver.name}Connection`,
+  });
+
+  resolver.addArgs({
+    first: 'Int',
+    after: 'String',
+    last: 'Int',
+    before: 'String',
+  });
+  resolver.removeArg('limit');
+  resolver.removeArg('skip');
+
+  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.resolve = async rp => {
+    const { args = {} } = rp;
+
+    const first = parseInt(args.first, 10) || 0;
+    if (first < 0) {
+      throw new Error('Argument `first` should be non-negative number.');
+    }
+    const last = parseInt(args.last, 10) || 0;
+    if (last < 0) {
+      throw new Error('Argument `last` should be non-negative number.');
+    }
+
+    let limit = last || first || 20;
+    let skip = last > 0 ? first - last : 0;
+
+    delete rp.args.last;
+    delete rp.args.first;
+    rp.args.limit = limit;
+    rp.args.skip = skip;
+
+    const res = await searchResolver.resolve(rp);
+    const list = res.hits.hits;
+    const result = {
+      ...res,
+      pageInfo: {},  // TODO <------------------
+      edges: list.map(node => ({ node, cursor: dataToCursor(node.sort) })),
+    };
+
+    return result;
+  };
+
+  return resolver;
+}
+
+function getPageInfoTC(opts: mixed = {}): TypeComposer {
+  const name = getTypeName('PageInfo', opts);
+
+  return getOrSetType(name, () =>
+    TypeComposer.create(
+      `
+      # Information about pagination in a connection.
+      type ${name} {
+        # When paginating forwards, are there more items?
+        hasNextPage: Boolean!
+
+        # When paginating backwards, are there more items?
+        hasPreviousPage: Boolean!
+
+        # When paginating backwards, the cursor to continue.
+        startCursor: String
+
+        # When paginating forwards, the cursor to continue.
+        endCursor: String
+      }
+    `
+    ));
+}
+
+export function base64(i: string): string {
+  return new Buffer(i, 'ascii').toString('base64');
+}
+
+export function unbase64(i: string): string {
+  return new Buffer(i, 'base64').toString('ascii');
+}
+
+export function cursorToData(cursor: string): mixed {
+  if (typeof cursor === 'string') {
+    try {
+      return JSON.parse(unbase64(cursor)) || null;
+    } catch (err) {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function dataToCursor(data: mixed): string {
+  return base64(JSON.stringify(data));
+}