feat: better type definitions for Relay Modern

This update provides some changes for graphql connection type
definitions. Now relay-compiler can generate better flowtype
declarations, which will require less runtime checks in your code.

Eg.
- `edges` can not be empty and do not require additional check in your
code is it null or not.
- `cursor` now have regular `String` type, before it casted by
relay-compiler to `any` flow type and does not provide proper checks out
of the box.

Author: nodkz

src/__tests__/composeWithConnection-test.js

@@ -2,7 +2,7 @@
 /* eslint-disable no-param-reassign */
 
 import { TypeComposer } from 'graphql-compose';
-import { GraphQLSchema, GraphQLList, graphql } from 'graphql-compose/lib/graphql';
+import { GraphQLSchema, GraphQLList, GraphQLNonNull, graphql } from 'graphql-compose/lib/graphql';
 import { composeWithConnection } from '../composeWithConnection';
 import { userTypeComposer, sortOptions } from '../__mocks__/userTypeComposer';
 import { rootQueryTypeComposer as rootQueryTC } from '../__mocks__/rootQueryTypeComposer';
@@ -63,7 +63,8 @@ describe('composeWithRelay', () => {
     it('should has ConnectionType as type', () => {
       expect(type).toBeTruthy();
       expect(tc.getFieldNames()).toEqual(expect.arrayContaining(['count', 'pageInfo', 'edges']));
-      expect(tc.getFieldType('edges')).toBeInstanceOf(GraphQLList);
+      expect(tc.getFieldType('edges')).toBeInstanceOf(GraphQLNonNull);
+      expect(tc.getFieldType('edges').ofType).toBeInstanceOf(GraphQLList);
     });
   });
 

src/__tests__/connectionResolver-test.js

@@ -2,11 +2,10 @@
 /* eslint-disable no-param-reassign */
 
 import { Resolver } from 'graphql-compose';
-import { GraphQLInt } from 'graphql-compose/lib/graphql';
+import { GraphQLInt, GraphQLString } from 'graphql-compose/lib/graphql';
 import { userTypeComposer, userList, sortOptions } from '../__mocks__/userTypeComposer';
 import { dataToCursor } from '../cursor';
 import { prepareConnectionResolver, prepareRawQuery, preparePageInfo } from '../connectionResolver';
-import Cursor from '../types/cursorType';
 
 describe('connectionResolver', () => {
   const connectionResolver = prepareConnectionResolver(userTypeComposer, {
@@ -92,12 +91,12 @@ describe('connectionResolver', () => {
 
     it('should have `after` arg', () => {
       // $FlowFixMe
-      expect(connectionResolver.getArg('after').type).toBe(Cursor);
+      expect(connectionResolver.getArg('after').type).toBe(GraphQLString);
     });
 
     it('should have `before` arg', () => {
       // $FlowFixMe
-      expect(connectionResolver.getArg('before').type).toBe(Cursor);
+      expect(connectionResolver.getArg('before').type).toBe(GraphQLString);
     });
 
     it('should have `sort` arg', () => {

src/connectionResolver.js

@@ -6,7 +6,6 @@ import type { ResolveParams, ProjectionType } from 'graphql-compose';
 import type { GraphQLResolveInfo } from 'graphql-compose/lib/graphql';
 import { prepareConnectionType } from './types/connectionType';
 import { prepareSortType } from './types/sortInputType';
-import CursorType from './types/cursorType';
 import { cursorToData, dataToCursor, type CursorDataType } from './cursor';
 import type { ComposeWithConnectionOpts } from './composeWithConnection';
 
@@ -124,15 +123,15 @@ export function prepareConnectionResolver<TSource, TContext>(
         description: 'Forward pagination argument for returning at most first edges',
       },
       after: {
-        type: CursorType,
+        type: 'String',
         description: 'Forward pagination argument for returning at most first edges',
       },
       last: {
         type: 'Int',
         description: 'Backward pagination argument for returning at most last edges',
       },
       before: {
-        type: CursorType,
+        type: 'String',
         description: 'Backward pagination argument for returning at most last edges',
       },
       ...additionalArgs,

src/types/__tests__/connectionType-test.js

@@ -6,11 +6,11 @@ import {
   GraphQLObjectType,
   getNamedType,
   GraphQLInt,
+  GraphQLString,
   GraphQLList,
 } from 'graphql-compose/lib/graphql';
 import { userTypeComposer } from '../../__mocks__/userTypeComposer';
 import { prepareEdgeType, prepareConnectionType } from '../connectionType';
-import GraphQLConnectionCursor from '../cursorType';
 import PageInfoType from '../pageInfoType';
 
 describe('types/connectionType.js', () => {
@@ -28,12 +28,12 @@ describe('types/connectionType.js', () => {
       expect(tc.getFieldType('node')).toBe(userTypeComposer.getType());
     });
 
-    it('should have field `cursor` with GraphQLNonNull(GraphQLConnectionCursor)', () => {
+    it('should have field `cursor` with GraphQLNonNull(GraphQLString)', () => {
       const tc = new TypeComposer(prepareEdgeType(userTypeComposer));
       expect(tc.getFieldType('cursor')).toBeInstanceOf(GraphQLNonNull);
 
       const cursor = getNamedType(tc.getFieldType('cursor'));
-      expect(cursor).toBe(GraphQLConnectionCursor);
+      expect(cursor).toBe(GraphQLString);
     });
 
     it('should have `ofType` property (like GraphQLList, GraphQLNonNull)', () => {
@@ -73,7 +73,8 @@ describe('types/connectionType.js', () => {
 
     it('should have field `edges` with GraphQLList(EdgeType)', () => {
       const tc = new TypeComposer(prepareConnectionType(userTypeComposer));
-      expect(tc.getFieldType('edges')).toBeInstanceOf(GraphQLList);
+      expect(tc.getFieldType('edges')).toBeInstanceOf(GraphQLNonNull);
+      expect(tc.getFieldType('edges').ofType).toBeInstanceOf(GraphQLList);
 
       const edges = getNamedType(tc.getFieldType('edges'));
       // $FlowFixMe

src/types/connectionType.js

@@ -3,12 +3,12 @@
 
 import {
   GraphQLInt,
+  GraphQLString,
   GraphQLObjectType,
   GraphQLNonNull,
   GraphQLList,
 } from 'graphql-compose/lib/graphql';
 import type { TypeComposer } from 'graphql-compose';
-import GraphQLConnectionCursor from './cursorType';
 
 import PageInfoType from './pageInfoType';
 
@@ -32,7 +32,7 @@ export function prepareEdgeType(typeComposer: TypeComposer): GraphQLObjectType {
         description: 'The item at the end of the edge',
       },
       cursor: {
-        type: new GraphQLNonNull(GraphQLConnectionCursor),
+        type: new GraphQLNonNull(GraphQLString),
         description: 'A cursor for use in pagination',
       },
     }),
@@ -68,7 +68,9 @@ export function prepareConnectionType(typeComposer: TypeComposer): GraphQLObject
         description: 'Information to aid in pagination.',
       },
       edges: {
-        type: new GraphQLList(prepareEdgeType(typeComposer)),
+        type: new GraphQLNonNull(
+          new GraphQLList(new GraphQLNonNull(prepareEdgeType(typeComposer)))
+        ),
         description: 'Information to aid in pagination.',
       },
     }),