fix(Flowtype): Resolve Flow errors. Cover tests by Flow.

Author: nodkz

.flowconfig

@@ -1,12 +1,38 @@
 [ignore]
-.*/__tests__/.*
-.*/__mocks__/.*
 .*/coverage/.*
 .*/resources/.*
 <PROJECT_ROOT>/lib/.*
 <PROJECT_ROOT>/dist/.*
-.*/node_modules/config-chain/test/broken.json
-.*/node_modules/npmconf/test/fixtures/package.json
+.*/node_modules/ajv.*
+.*/node_modules/acorn.*
+.*/node_modules/async.*
+.*/node_modules/babel.*
+.*/node_modules/bluebird.*
+.*/node_modules/caniuse-db.*
+.*/node_modules/config-chain.*
+.*/node_modules/conventional-changelog.*
+.*/node_modules/core-js.*
+.*/node_modules/cssstyle.*
+.*/node_modules/diff.*
+.*/node_modules/es5-ext.*
+.*/node_modules/escope.*
+.*/node_modules/escodegen.*
+.*/node_modules/eslint.*
+.*/node_modules/github.*
+.*/node_modules/fsevents.*
+.*/node_modules/jsdoctypeparser.*
+.*/node_modules/jsdom.*
+.*/node_modules/iconv.*
+.*/node_modules/istanbul.*
+.*/node_modules/handlebars.*
+.*/node_modules/markdown.*
+.*/node_modules/node-notifier.*
+.*/node_modules/npmconf.*
+.*/node_modules/prettier.*
+.*/node_modules/source-map.*
+.*/node_modules/travis.*
+.*/node_modules/uglify.*
+.*/node_modules/yargs.*
 
 [include]
 

package.json

@@ -23,7 +23,7 @@
   },
   "homepage": "https://github.com/nodkz/graphql-compose-connection",
   "peerDependencies": {
-    "graphql-compose": ">=1.20.2"
+    "graphql-compose": ">=1.20.3"
   },
   "devDependencies": {
     "babel-cli": "^6.24.1",
@@ -42,7 +42,7 @@
     "eslint-plugin-prettier": "^2.1.1",
     "flow-bin": "^0.47.0",
     "graphql": "^0.10.1",
-    "graphql-compose": "^1.20.2",
+    "graphql-compose": "^1.20.3",
     "jest": "^20.0.4",
     "prettier": "^1.4.2",
     "rimraf": "^2.6.1",
@@ -64,7 +64,7 @@
     "lint": "eslint src test *.js",
     "test": "jest",
     "watch": "jest --watch",
-    "flow": "./node_modules/.bin/flow",
+    "flow": "./node_modules/.bin/flow stop && ./node_modules/.bin/flow",
     "all": "npm run test && npm run lint && npm run flow",
     "link": "yarn build && yarn link graphql-compose && yarn link",
     "unlink": "yarn unlink graphql-compose && yarn add graphql-compose",

src/__mocks__/userTypeComposer.js

@@ -3,6 +3,8 @@
 
 import { TypeComposer, Resolver, graphql } from 'graphql-compose';
 
+import type { ConnectionSortMapOpts } from '../definition';
+
 const {
   GraphQLString,
   GraphQLObjectType,
@@ -171,7 +173,7 @@ export const countResolver = new Resolver({
 });
 userTypeComposer.setResolver('count', countResolver);
 
-export const sortOptions = {
+export const sortOptions: ConnectionSortMapOpts = {
   ID_ASC: {
     value: { id: 1 },
     cursorFields: ['id'],

src/__tests__/composeWithConnection-test.js

@@ -21,10 +21,12 @@ describe('composeWithRelay', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
+      // $FlowFixMe
       expect(() => composeWithConnection(123)).toThrowError('should provide TypeComposer instance');
     });
 
     it('should throw error if options are empty', () => {
+      // $FlowFixMe
       expect(() => composeWithConnection(userTypeComposer)).toThrowError(
         'should provide non-empty options'
       );
@@ -52,6 +54,7 @@ describe('composeWithRelay', () => {
   describe('check `connection` resolver props', () => {
     const rsv = userComposer.getResolver('connection');
     const type = rsv.getType();
+    // $FlowFixMe
     const tc = new TypeComposer(type);
 
     it('should exists', () => {
@@ -92,6 +95,8 @@ describe('composeWithRelay', () => {
       }
     }`;
     const result = await graphql.graphql(schema, query);
+
+    // $FlowFixMe
     expect(result.data.userConnection).toEqual({
       count: 15,
       pageInfo: {
@@ -145,6 +150,8 @@ describe('composeWithRelay', () => {
       }
     }`;
     const result = await graphql.graphql(schema, query);
+
+    // $FlowFixMe
     expect(result.data.userConnection).toEqual({
       count: 15,
       pageInfo: {
@@ -258,9 +265,11 @@ describe('composeWithRelay', () => {
       }
     }`;
     await graphql.graphql(schema, query);
+    // $FlowFixMe
     expect(Object.keys(topResolveParams.countResolveParams)).toEqual(
       expect.arrayContaining(['source', 'args', 'context', 'info', 'projection'])
     );
+    // $FlowFixMe
     expect(topResolveParams.countResolveParams.args).toEqual({
       filter: { age: 45 },
     });
@@ -289,9 +298,11 @@ describe('composeWithRelay', () => {
       }
     }`;
     await graphql.graphql(schema, query);
+    // $FlowFixMe
     expect(Object.keys(topResolveParams.findManyResolveParams)).toEqual(
       expect.arrayContaining(['source', 'args', 'context', 'info', 'projection'])
     );
+    // $FlowFixMe
     expect(topResolveParams.findManyResolveParams.args).toEqual({
       filter: { age: 45 },
       limit: 2,

src/__tests__/connectionResolver-test.js

@@ -22,12 +22,14 @@ describe('connectionResolver', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
+      // $FlowFixMe
       expect(() => prepareConnectionResolver(123)).toThrowError(
         'should be instance of TypeComposer'
       );
     });
 
     it('should throw error if opts.countResolverName are empty', () => {
+      // $FlowFixMe
       expect(() => prepareConnectionResolver(userTypeComposer, {})).toThrowError(
         'should have option `opts.countResolverName`'
       );
@@ -45,6 +47,7 @@ describe('connectionResolver', () => {
 
     it('should throw error if opts.findResolverName are empty', () => {
       expect(() =>
+        // $FlowFixMe
         prepareConnectionResolver(userTypeComposer, {
           countResolverName: 'count',
         })
@@ -72,28 +75,34 @@ describe('connectionResolver', () => {
     });
 
     it('should have type to be ConnectionType', () => {
+      // $FlowFixMe
       expect(connectionResolver.type.name).toBe('UserConnection');
     });
   });
 
   describe('resolver args', () => {
     it('should have `first` arg', () => {
+      // $FlowFixMe
       expect(connectionResolver.getArg('first').type).toBe(GraphQLInt);
     });
 
     it('should have `last` arg', () => {
+      // $FlowFixMe
       expect(connectionResolver.getArg('last').type).toBe(GraphQLInt);
     });
 
     it('should have `after` arg', () => {
+      // $FlowFixMe
       expect(connectionResolver.getArg('after').type).toBe(Cursor);
     });
 
     it('should have `before` arg', () => {
+      // $FlowFixMe
       expect(connectionResolver.getArg('before').type).toBe(Cursor);
     });
 
     it('should have `sort` arg', () => {
+      // $FlowFixMe
       expect(connectionResolver.getArg('sort').type.name).toBe('SortConnectionUserEnum');
     });
   });
@@ -173,8 +182,8 @@ describe('connectionResolver', () => {
           count: true,
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(true);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(false);
+      expect(countResolverCalled).toBe(true);
+      expect(findManyResolverCalled).toBe(false);
     });
 
     it('should call count and findMany resolver when not only count is projected', async () => {
@@ -190,8 +199,8 @@ describe('connectionResolver', () => {
           },
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(true);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(true);
+      expect(countResolverCalled).toBe(true);
+      expect(findManyResolverCalled).toBe(true);
     });
 
     it('should call findMany and not count when arbitrary top level fields are projected without count', async () => {
@@ -202,8 +211,8 @@ describe('connectionResolver', () => {
           age: true,
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(false);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(true);
+      expect(countResolverCalled).toBe(false);
+      expect(findManyResolverCalled).toBe(true);
     });
 
     it('should call findMany and count when arbitrary top level fields are projected with count', async () => {
@@ -215,8 +224,8 @@ describe('connectionResolver', () => {
           age: true,
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(true);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(true);
+      expect(countResolverCalled).toBe(true);
+      expect(findManyResolverCalled).toBe(true);
     });
 
     it('should call count and findMany resolver when last arg is used but not first arg', async () => {
@@ -233,8 +242,8 @@ describe('connectionResolver', () => {
           },
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(true);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(true);
+      expect(countResolverCalled).toBe(true);
+      expect(findManyResolverCalled).toBe(true);
     });
 
     it('should call findMany but not count resolver when first arg is used', async () => {
@@ -249,8 +258,8 @@ describe('connectionResolver', () => {
           },
         },
       });
-      expect(countResolverCalled, 'count resolver called').toBe(false);
-      expect(findManyResolverCalled, 'findMany resolver called').toBe(true);
+      expect(countResolverCalled).toBe(false);
+      expect(findManyResolverCalled).toBe(true);
     });
   });
 
@@ -270,9 +279,10 @@ describe('connectionResolver', () => {
 
     it('should setup in resolveParams.rawQuery', () => {
       const rp = {
-        args: { filter: 123 },
+        args: { filter: { id: 123 } },
       };
       prepareRawQuery(rp, sortConfig);
+      // $FlowFixMe
       expect(rp.rawQuery).toEqual({});
     });
 
@@ -286,6 +296,8 @@ describe('connectionResolver', () => {
         rawQuery,
       };
       const dumbSortConfig = {
+        value: { id: 1 },
+        cursorFields: ['id'],
         beforeCursorQuery: () => {},
         afterCursorQuery: () => {},
       };
@@ -297,21 +309,23 @@ describe('connectionResolver', () => {
       const rp = {
         args: {
           after: dataToCursor({ id: 123 }),
-          sort: { id: 1 },
+          sort: sortConfig,
         },
       };
       prepareRawQuery(rp, sortConfig);
+      // $FlowFixMe
       expect(rp.rawQuery).toEqual({ after: { id: 123 } });
     });
 
     it('should call beforeCursorQuery if provided args.before', () => {
       const rp = {
         args: {
           before: dataToCursor({ id: 234 }),
-          sort: { id: 1 },
+          sort: sortConfig,
         },
       };
       prepareRawQuery(rp, sortConfig);
+      // $FlowFixMe
       expect(rp.rawQuery).toEqual({ before: { id: 234 } });
     });
 

src/composeWithConnection.js

@@ -1,12 +1,12 @@
 /* @flow */
 
 import { TypeComposer } from 'graphql-compose';
-import type { composeWithConnectionOpts } from './definition';
+import type { ComposeWithConnectionOpts } from './definition';
 import { prepareConnectionResolver } from './connectionResolver';
 
 export function composeWithConnection(
   typeComposer: TypeComposer,
-  opts: composeWithConnectionOpts
+  opts: ComposeWithConnectionOpts
 ): TypeComposer {
   if (!(typeComposer instanceof TypeComposer)) {
     throw new Error('You should provide TypeComposer instance to composeWithRelay method');

src/connectionResolver.js

@@ -5,9 +5,9 @@ import { Resolver, TypeComposer } from 'graphql-compose';
 import type {
   ResolveParams,
   ConnectionResolveParams,
-  composeWithConnectionOpts,
-  connectionSortOpts,
-  connectionSortMapOpts,
+  ComposeWithConnectionOpts,
+  ConnectionSortOpts,
+  ConnectionSortMapOpts,
   GraphQLConnectionType,
 } from './definition';
 import { prepareConnectionType } from './types/connectionType';
@@ -17,7 +17,7 @@ import { cursorToData, dataToCursor } from './cursor';
 
 export function prepareConnectionResolver<TSource, TContext>(
   typeComposer: TypeComposer,
-  opts: composeWithConnectionOpts
+  opts: ComposeWithConnectionOpts
 ): Resolver<TSource, TContext> {
   if (!(typeComposer instanceof TypeComposer)) {
     throw new Error('First arg for prepareConnectionResolver() should be instance of TypeComposer');
@@ -147,7 +147,7 @@ export function prepareConnectionResolver<TSource, TContext>(
       let skip = last > 0 ? first - last : 0;
 
       let prepareCursorData;
-      const sortConfig: ?connectionSortOpts = findSortConfig(opts.sort, args.sort);
+      const sortConfig: ?ConnectionSortOpts = findSortConfig(opts.sort, args.sort);
       if (sortConfig) {
         prepareRawQuery(resolveParams, sortConfig);
         findManyParams.rawQuery = resolveParams.rawQuery;
@@ -250,7 +250,7 @@ export function preparePageInfo(
 
 export function prepareRawQuery(
   rp: $Shape<ConnectionResolveParams<*, *>>,
-  sortConfig: connectionSortOpts
+  sortConfig: ConnectionSortOpts
 ) {
   if (!rp.rawQuery) {
     rp.rawQuery = {};
@@ -339,7 +339,7 @@ export function emptyConnection(): GraphQLConnectionType {
   };
 }
 
-export function findSortConfig(configs: connectionSortMapOpts, val: mixed): ?connectionSortOpts {
+export function findSortConfig(configs: ConnectionSortMapOpts, val: mixed): ?ConnectionSortOpts {
   // Object.keys(configs).forEach(k => {  // return does not works in forEach as I want
   for (const k in configs) {
     if (configs[k].value === val) {