Fix connection resolver due spec

To determine what edges to return, the connection evaluates the before and after cursors to filter the edges, then evaluates first to slice the edges, then last to slice the edges.
https://facebook.github.io/relay/graphql/connections.htm#sec-Pagination-algorithm

Author: nodkz

src/composeWithConnection.js

@@ -24,7 +24,7 @@ export function composeWithConnection(
 
   const resolver = prepareConnectionResolver(
     typeComposer,
-    opts,
+    opts
   );
 
   typeComposer.addResolver(resolver);

src/definition.js

@@ -5,6 +5,22 @@ import type {
   ResolveParams as _ResolveParams,
 } from 'graphql-compose/lib/definition.js';
 
+export type composeWithConnectionOpts = {
+  findResolverName: string,
+  countResolverName: string,
+  sort: connectionSortMapOpts,
+};
+
+export type connectionSortMapOpts = {
+  [sortName: string]: connectionSortOpts,
+};
+
+export type connectionSortOpts = {
+  uniqueFields: string[],
+  sortValue: mixed,
+  directionFilter: (<T>(cursorData: CursorDataType, filterArg: T, isBefore: boolean) => T),
+};
+
 export type ResolveParams = _ResolveParams;
 
 export type ConnectionResolveParams = {
@@ -27,22 +43,6 @@ export type CursorDataType = {
   [fieldName: string]: mixed,
 };
 
-export type connectionSortOpts = {
-  uniqueFields: string[],
-  sortValue: mixed,
-  cursorToFilter: (<T>(cursorData: CursorDataType, filterArg: T) => T),
-};
-
-export type connectionSortMapOpts = {
-  [sortName: string]: connectionSortOpts,
-};
-
-export type composeWithConnectionOpts = {
-  findResolverName: string,
-  countResolverName: string,
-  sort: connectionSortMapOpts,
-};
-
 export type GraphQLConnectionType = {
   count: number,
   edges: [GraphQLConnectionEdgeType],

src/resolvers/connectionResolver.js

@@ -75,11 +75,12 @@ export function prepareConnectionResolver(
       ...additionalArgs,
       sort: {
         type: sortEnumType,
-        defaultValue: sortEnumType.getValues()[0].name, // first enum used by default
+        defaultValue: sortEnumType.getValues()[0].value, // first enum used by default
         description: 'Sort argument for data ordering',
       },
     },
-    resolve: (resolveParams: ConnectionResolveParams) => {
+    resolve: async (resolveParams: ConnectionResolveParams) => {
+      let countPromise;
       const { projection = {}, args = {} } = resolveParams;
       const findManyParams: ResolveParams = Object.assign(
         {},
@@ -88,39 +89,51 @@ export function prepareConnectionResolver(
       );
       const sortOptions: connectionSortOpts = args.sort;
 
-      const first = parseInt(args.first, 10);
+      let filter = resolveParams.args.filter || {};
+      const beginCursorData = cursorToData(args.after);
+      if (beginCursorData) {
+        filter = sortOptions.directionFilter(beginCursorData, filter, false);
+      }
+      const endCursorData = cursorToData(args.before);
+      if (endCursorData) {
+        filter = sortOptions.directionFilter(endCursorData, filter, true);
+      }
+      findManyParams.args.filter = filter;
+
+
+      let first = parseInt(args.first, 10);
       const last = parseInt(args.last, 10);
 
-      const limit = last || first;
+      if (projection.count) {
+        countPromise = countResolve(findManyParams);
+      } else if (!first && last) {
+        countPromise = countResolve(findManyParams);
+      } else {
+        countPromise = Promise.resolve(0);
+      }
+
+      if (!first && last) {
+        first = (await countPromise) || 0;
+      }
+
+      const limit = first;
       const skip = (first - last) || 0;
 
       findManyParams.args.limit = limit + 1; // +1 document, to check next page presence
       if (skip > 0) {
         findManyParams.args.skip = skip;
       }
 
-      let filter = findManyParams.args.filter || {};
-      const beginCursorData = cursorToData(args.after);
-      if (beginCursorData) {
-        filter = sortOptions.cursorToFilter(beginCursorData, filter);
-      }
-      const endCursorData = cursorToData(args.before);
-      if (endCursorData) {
-        filter = sortOptions.cursorToFilter(endCursorData, filter);
-      }
-      findManyParams.args.filter = filter;
-      findManyParams.args.skip = skip;
-
       findManyParams.args.sort = sortOptions.sortValue;
       findManyParams.projection = projection;
       sortOptions.uniqueFields.forEach(fieldName => {
         findManyParams.projection[fieldName] = true;
       });
 
-      let countPromise;
-      if (projection.count) {
-        countPromise = countResolve(resolveParams);
-      }
+findManyParams.projection['count'] = true;
+findManyParams.projection['age'] = true;
+findManyParams.projection['name'] = true;
+
       const hasPreviousPage = skip > 0;
       let hasNextPage = false; // will be requested +1 document, to check next page presence
 
@@ -132,13 +145,15 @@ export function prepareConnectionResolver(
         return result;
       };
 
-      return findManyResolve(findManyParams)
-        .then(recordList => {
+console.log(findManyParams.args);
+
+      return Promise.all([findManyResolve(findManyParams), countPromise])
+        .then(([recordList, count]) => {
           const edges = [];
           // if returned more than `limit` records, strip array and mark that exists next page
           if (recordList.length > limit) {
             hasNextPage = true;
-            recordList = recordList.slice(0, limit - 1);
+            recordList = recordList.slice(0, limit);
           }
           // transform record to object { cursor, node }
           recordList.forEach(record => {
@@ -147,18 +162,12 @@ export function prepareConnectionResolver(
               node: record,
             });
           });
-          return edges;
+          return [edges, count];
         })
-        .then(async (edges) => {
+        .then(([edges, count]) => {
           const result = emptyConnection();
-
-          // pass `edge` data
           result.edges = edges;
-
-          // if exists countPromise, await it's data
-          if (countPromise) {
-            result.count = await countPromise;
-          }
+          result.count = count;
 
           // pageInfo may be extended, so set data gradually
           if (edges.length > 0) {
@@ -187,17 +196,17 @@ export function emptyConnection(): GraphQLConnectionType {
   };
 }
 
-export function cursorToData(id?: ?string): ?CursorDataType {
-  if (id) {
+export function cursorToData(cursor?: ?string): ?CursorDataType {
+  if (cursor) {
     try {
-      return JSON.parse(id) || null;
+      return JSON.parse(cursor) || null;
     } catch (err) {
       return null;
     }
   }
   return null;
 }
 
-export function dataToCursor(cursorData: CursorDataType): string {
-  return JSON.stringify(cursorData);
+export function dataToCursor(data: CursorDataType): string {
+  return JSON.stringify(data);
 }

src/types/sortInputType.js

@@ -45,11 +45,6 @@ export function prepareSortType(
 
 
 export function checkSortOpts(key: string, opts: connectionSortOpts) {
-  if (!opts.resolver) {
-    throw new Error('You should provide `resolver` option '
-                  + `for composeWithConnection in opts.sort.${key}`);
-  }
-
   if (!opts.uniqueFields || !Array.isArray(opts.uniqueFields)) {
     throw new Error('You should array of field(s) in `uniqueFields` '
                   + `for composeWithConnection in opts.sort.${key}`
@@ -63,10 +58,10 @@ export function checkSortOpts(key: string, opts: connectionSortOpts) {
                   + 'Connections does not work without sorting.');
   }
 
-  if (!opts.cursorToFilter || !isFunction(opts.cursorToFilter)) {
-    throw new Error('You should provide `cursorToFilter` function '
+  if (!opts.directionFilter || !isFunction(opts.directionFilter)) {
+    throw new Error('You should provide `directionFilter` function '
                   + `for composeWithConnection in opts.sort.${key}. `
-                  + 'Connections should have ability to filter record '
-                  + 'by data dirived from cursor.');
+                  + 'Connections should have ability to filter '
+                  + 'forward/backward records started from cursor.');
   }
 }