Finalize ConnectionResolver

Author: nodkz

src/composeWithConnection.js

@@ -29,3 +29,4 @@ export function composeWithConnection(
 
   typeComposer.addResolver(resolver);
   return typeComposer;
+}

src/connectionResolver.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 import { cursorToId, idToCursor, dotObject } from '../utils';
 import { projectionCollection, projectionFixRenamed } from './projection';
 import {

src/cursorId.js

@@ -1,21 +1,62 @@
 /* @flow */
 /* eslint-disable */
 
-export type CursorData = {
+import type {
+  ResolveParams as _ResolveParams,
+} from 'graphql-compose/lib/definition.js';
+
+export type ResolveParams = _ResolveParams;
+
+export type ConnectionResolveParams = {
+  source: mixed,
+  args: {
+    first?: ?number,
+    after?: ?string,
+    last?: ?number,
+    before?: ?string,
+    sort: connectionSortOpts,
+    [argName: string]: mixed,
+  },
+  context: mixed,
+  info: any,
+  projection: { [fieldName: string]: true },
+  [opt: string]: mixed,
+};
+
+export type CursorDataType = {
   [fieldName: string]: mixed,
 };
 
 export type connectionSortOpts = {
-  resolver: string,
   uniqueFields: string[],
   sortValue: mixed,
-  cursorToFilter: (<T>(cursorData: CursorData, filterArg: T) => T),
+  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],
+  pageInfo: PageInfoType,
+}
+
+export type GraphQLConnectionEdgeType = {
+  cursor: string,
+  node: mixed,
+}
+
+export type PageInfoType = {
+  startCursor: string,
+  endCursor: string,
+  hasPreviousPage: boolean,
+  hasNextPage: boolean,
+}

src/definition.js

@@ -2,9 +2,12 @@
 /* eslint-disable no-param-reassign, no-use-before-define */
 
 import type {
-  ExtendedResolveParams,
+  ResolveParams,
+  ConnectionResolveParams,
   composeWithConnectionOpts,
   connectionSortOpts,
+  CursorDataType,
+  GraphQLConnectionType,
 } from '../definition';
 import { Resolver, TypeComposer } from 'graphql-compose';
 import { GraphQLInt } from 'graphql';
@@ -25,15 +28,21 @@ export function prepareConnectionResolver(
                   + 'This function returns ID from provided object.');
   }
 
-  const countResolver = typeComposer.getResolver('count');
+  const countResolver = typeComposer.getResolver(opts.countResolverName);
   if (!countResolver) {
-    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) should have 'count' resolver`);
+    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) provided to composeWithConnection `
+                  + `should have resolver with name '${opts.countResolverName}' `
+                  + 'due opts.countResolverName.');
   }
+  const countResolve = countResolver.composeResolve();
 
-  const findManyResolver = typeComposer.getResolver('findMany');
+  const findManyResolver = typeComposer.getResolver(opts.findResolverName);
   if (!findManyResolver) {
-    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) should have 'findMany' resolver`);
+    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) provided to composeWithConnection `
+                  + `should have resolver with name '${opts.findResolverName}' `
+                  + 'due opts.countResolverName.');
   }
+  const findManyResolve = findManyResolver.composeResolve();
 
   const additionalArgs = {};
   if (findManyResolver.hasArg('filter')) {
@@ -70,16 +79,17 @@ export function prepareConnectionResolver(
         description: 'Sort argument for data ordering',
       },
     },
-    resolve: (resolveParams: ExtendedResolveParams) => {
+    resolve: (resolveParams: ConnectionResolveParams) => {
       const { projection = {}, args = {} } = resolveParams;
-      const findManyParams = Object.assign({}, resolveParams, {
-        args: {},
-        projection: {},
-      });
-      const connSortOpts: connectionSortOpts = resolveParams.args.sort;
+      const findManyParams: ResolveParams = Object.assign(
+        {},
+        resolveParams,
+        { args: {} } // clear this params in copy
+      );
+      const sortOptions: connectionSortOpts = args.sort;
 
-      const first = args.first;
-      const last = args.last;
+      const first = parseInt(args.first, 10);
+      const last = parseInt(args.last, 10);
 
       const limit = last || first;
       const skip = (first - last) || 0;
@@ -89,30 +99,40 @@ export function prepareConnectionResolver(
         findManyParams.args.skip = skip;
       }
 
-      let filter = findManyParams.args.filter;
+      let filter = findManyParams.args.filter || {};
       const beginCursorData = cursorToData(args.after);
       if (beginCursorData) {
-        filter = connSortOpts.cursorToFilter(beginCursorData, filter);
+        filter = sortOptions.cursorToFilter(beginCursorData, filter);
       }
       const endCursorData = cursorToData(args.before);
       if (endCursorData) {
-        filter = connSortOpts.cursorToFilter(endCursorData, filter);
+        filter = sortOptions.cursorToFilter(endCursorData, filter);
       }
       findManyParams.args.filter = filter;
-
       findManyParams.args.skip = skip;
-      // findManyParams.args.sort  // TODO
-      // findManyParams.projection  // TODO
+
+      findManyParams.args.sort = sortOptions.sortValue;
+      findManyParams.projection = projection;
+      sortOptions.uniqueFields.forEach(fieldName => {
+        findManyParams.projection[fieldName] = true;
+      });
 
       let countPromise;
       if (projection.count) {
-        countPromise = countResolver(resolveParams);
+        countPromise = countResolve(resolveParams);
       }
-      const findManyPromise = findManyResolver(findManyParams);
       const hasPreviousPage = skip > 0;
       let hasNextPage = false; // will be requested +1 document, to check next page presence
 
-      return findManyPromise
+      const filterDataForCursor = (record) => {
+        const result = {};
+        sortOptions.uniqueFields.forEach(fieldName => {
+          result[fieldName] = record[fieldName];
+        });
+        return result;
+      };
+
+      return findManyResolve(findManyParams)
         .then(recordList => {
           const edges = [];
           // if returned more than `limit` records, strip array and mark that exists next page
@@ -122,9 +142,8 @@ export function prepareConnectionResolver(
           }
           // transform record to object { cursor, node }
           recordList.forEach(record => {
-            const id = typeComposer.getRecordId(record);
             edges.push({
-              cursor: idToCursor(id),
+              cursor: dataToCursor(filterDataForCursor(record)),
               node: record,
             });
           });
@@ -155,41 +174,30 @@ export function prepareConnectionResolver(
   });
 }
 
-export function emptyConnection() {
+export function emptyConnection(): GraphQLConnectionType {
   return {
     count: 0,
     edges: [],
     pageInfo: {
-      startCursor: null,
-      endCursor: null,
+      startCursor: '',
+      endCursor: '',
       hasPreviousPage: false,
       hasNextPage: false,
     },
   };
 }
 
-export function idToCursor(id: string) {
-  return id;
-}
-
-export function cursorToId(cursor: string) {
-  return cursor;
-}
-
-
-
-var PREFIX = 'arrayconnection:';
-
-/**
- * Creates the cursor string from an offset.
- */
-export function offsetToCursor(offset: number): ConnectionCursor {
-  return base64(PREFIX + offset);
+export function cursorToData(id?: ?string): ?CursorDataType {
+  if (id) {
+    try {
+      return JSON.parse(id) || null;
+    } catch (err) {
+      return null;
+    }
+  }
+  return null;
 }
 
-/**
- * Rederives the offset from the cursor string.
- */
-export function cursorToOffset(cursor: ConnectionCursor): number {
-  return parseInt(unbase64(cursor).substring(PREFIX.length), 10);
+export function dataToCursor(cursorData: CursorDataType): string {
+  return JSON.stringify(cursorData);
 }

src/resolvers/connectionResolver.js

@@ -7,7 +7,7 @@ import {
   GraphQLNonNull,
   GraphQLList,
 } from 'graphql';
-import GraphQLConnectionCursor from './сursorType';
+import GraphQLConnectionCursor from './cursorType';
 import type {
   TypeComposer,
 } from 'graphql-compose';

src/types/connectionType.js

@@ -7,7 +7,7 @@ import type {
   composeWithConnectionOpts,
   connectionSortOpts,
 } from '../definition.js';
-import { isFunction } from '../misc/is';
+import { isFunction } from '../utils/is';
 
 export function prepareSortType(
   typeComposer: TypeComposer,
@@ -27,7 +27,7 @@ export function prepareSortType(
 
   const sortEnumValues = {};
   sortKeys.forEach(sortKey => {
-    checkSortOpts(sortKey, opts.sort[sortKey], typeComposer);
+    checkSortOpts(sortKey, opts.sort[sortKey]);
 
     sortEnumValues[sortKey] = {
       name: sortKey,
@@ -44,19 +44,12 @@ export function prepareSortType(
 }
 
 
-export function checkSortOpts(key: string, opts: connectionSortOpts, typeComposer: TypeComposer) {
+export function checkSortOpts(key: string, opts: connectionSortOpts) {
   if (!opts.resolver) {
     throw new Error('You should provide `resolver` option '
                   + `for composeWithConnection in opts.sort.${key}`);
   }
 
-  const resolver = typeComposer.getResolver(opts.resolver);
-  if (!resolver) {
-    throw new Error(`TypeComposer(${typeComposer.getTypeName()}) provided to composeWithConnection `
-                  + `does not have resolver with name '${opts.resolver}' `
-                  + `for 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}`

src/types/sortInputType.js

@@ -1,7 +1,7 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
 
-export default function deepmerge(target: Object | void, src: Object): Object | mixed[] {
+export default function deepmerge(target: Object, src: Object): Object | mixed[] {
   if (Array.isArray(src)) {
     let dst = [];
     target = target || [];