fix(Flowtype): More strict type checks

Author: nodkz

.eslintrc

@@ -28,6 +28,7 @@
     }],
     "no-unused-expressions": 0,
     "no-restricted-syntax": 0,
+    "prefer-destructuring": 0,
   },
   "env": {
     "jasmine": true,

package.json

@@ -69,7 +69,7 @@
     "watch": "jest --watch",
     "coverage": "jest --coverage",
     "lint": "eslint --ext .js ./src",
-    "flow": "./node_modules/.bin/flow stop && ./node_modules/.bin/flow",
+    "flow": "./node_modules/.bin/flow",
     "test": "npm run coverage && 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/__tests__/composeWithPagination-test.js

@@ -20,15 +20,17 @@ describe('composeWithRelay', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
-      // $FlowFixMe
-      expect(() => composeWithPagination(123)).toThrowError('should provide TypeComposer instance');
+      expect(() => {
+        const args: any = [123];
+        composeWithPagination(...args);
+      }).toThrowError('should provide TypeComposer instance');
     });
 
     it('should throw error if options are empty', () => {
-      // $FlowFixMe
-      expect(() => composeWithPagination(userTypeComposer)).toThrowError(
-        'should provide non-empty options'
-      );
+      expect(() => {
+        const args: any = [userTypeComposer];
+        composeWithPagination(...args);
+      }).toThrowError('should provide non-empty options');
     });
 
     it('should not change `pagination` resolver if exists', () => {
@@ -51,8 +53,7 @@ describe('composeWithRelay', () => {
 
   describe('check `pagination` resolver props', () => {
     const rsv = userComposer.getResolver('pagination');
-    const type = rsv.getType();
-    // $FlowFixMe
+    const type: any = rsv.getType();
     const tc = new TypeComposer(type);
 
     it('should exists', () => {
@@ -123,7 +124,7 @@ describe('composeWithRelay', () => {
   });
 
   it('should pass `countResolveParams` to top resolverParams', async () => {
-    let topResolveParams;
+    let topResolveParams: any = {};
 
     rootQueryTC.setField(
       'userPagination',
@@ -142,18 +143,17 @@ describe('composeWithRelay', () => {
       }
     }`;
     await 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 },
     });
   });
 
   it('should pass `findManyResolveParams` to top resolverParams', async () => {
-    let topResolveParams;
+    let topResolveParams: any = {};
 
     rootQueryTC.setField(
       'userPagination',
@@ -172,11 +172,11 @@ describe('composeWithRelay', () => {
       }
     }`;
     await 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: 6,

src/__tests__/paginationResolver-test.js

@@ -21,17 +21,17 @@ describe('paginationResolver', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
-      // $FlowFixMe
-      expect(() => preparePaginationResolver(123)).toThrowError(
-        'should be instance of TypeComposer'
-      );
+      expect(() => {
+        const args: any = [123];
+        preparePaginationResolver(...args);
+      }).toThrowError('should be instance of TypeComposer');
     });
 
     it('should throw error if opts.countResolverName are empty', () => {
-      // $FlowFixMe
-      expect(() => preparePaginationResolver(userTypeComposer, {})).toThrowError(
-        'should have option `opts.countResolverName`'
-      );
+      expect(() => {
+        const args: any = [userTypeComposer, {}];
+        preparePaginationResolver(...args);
+      }).toThrowError('should have option `opts.countResolverName`');
     });
 
     it('should throw error if resolver opts.countResolverName does not exists', () => {
@@ -44,12 +44,10 @@ describe('paginationResolver', () => {
     });
 
     it('should throw error if opts.findResolverName are empty', () => {
-      expect(() =>
-        // $FlowFixMe
-        preparePaginationResolver(userTypeComposer, {
-          countResolverName: 'count',
-        })
-      ).toThrowError('should have option `opts.findResolverName`');
+      expect(() => {
+        const args: any = [userTypeComposer, { countResolverName: 'count' }];
+        preparePaginationResolver(...args);
+      }).toThrowError('should have option `opts.findResolverName`');
     });
 
     it('should throw error if resolver opts.countResolverName does not exists', () => {
@@ -72,19 +70,16 @@ describe('paginationResolver', () => {
     });
 
     it('should have type to be ConnectionType', () => {
-      // $FlowFixMe
-      expect(paginationResolver.type.name).toBe('UserPagination');
+      expect((paginationResolver.type: any).name).toBe('UserPagination');
     });
   });
 
   describe('resolver args', () => {
     it('should have `page` arg', () => {
-      // $FlowFixMe
       expect(paginationResolver.getArg('page').type).toBe(GraphQLInt);
     });
 
     it('should have `perPage` arg', () => {
-      // $FlowFixMe
       expect(paginationResolver.getArg('perPage').type).toBe(GraphQLInt);
     });
   });

src/paginationResolver.js

@@ -107,7 +107,7 @@ export function preparePaginationResolver<TSource, TContext>(
         description: '',
         defaultValue: opts.perPage || DEFAULT_PER_PAGE,
       },
-      ...additionalArgs,
+      ...(additionalArgs: any),
     },
     // eslint-disable-next-line
     resolve: async (resolveParams: $Shape<PaginationResolveParams<TSource, TContext>>) => {

src/types/__tests__/paginationType-test.js

@@ -39,16 +39,14 @@ describe('types/paginationType.js', () => {
       const tc = new TypeComposer(preparePaginationType(userTypeComposer));
       expect(tc.getFieldType('items')).toBeInstanceOf(GraphQLList);
 
-      const items = getNamedType(tc.getFieldType('items'));
-      // $FlowFixMe
+      const items: any = getNamedType(tc.getFieldType('items'));
       expect(items.name).toEqual('User');
     });
 
     it('should have `ofType` property (like GraphQLList, GraphQLNonNull)', () => {
       // this behavior needed for `graphql-compose` module in `projection` helper
       // otherwise it incorrectly construct projectionMapper for tricky fields
-      const connectionType = preparePaginationType(userTypeComposer);
-      // $FlowFixMe
+      const connectionType: any = preparePaginationType(userTypeComposer);
       expect(connectionType.ofType).toEqual(userTypeComposer.getType());
     });