fix(Flowtype): more strict type checks

Author: nodkz

src/__tests__/composeWithConnection-test.js

@@ -20,15 +20,17 @@ describe('composeWithRelay', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
-      // $FlowFixMe
-      expect(() => composeWithConnection(123)).toThrowError('should provide TypeComposer instance');
+      expect(() => {
+        const wrongArgs: any = [123];
+        composeWithConnection(...wrongArgs);
+      }).toThrowError('should provide TypeComposer instance');
     });
 
     it('should throw error if options are empty', () => {
-      // $FlowFixMe
-      expect(() => composeWithConnection(userTypeComposer)).toThrowError(
-        'should provide non-empty options'
-      );
+      expect(() => {
+        const wrongArgs: any = [userTypeComposer];
+        composeWithConnection(...wrongArgs);
+      }).toThrowError('should provide non-empty options');
     });
 
     it('should not change `connection` resolver if exists', () => {
@@ -52,8 +54,7 @@ describe('composeWithRelay', () => {
 
   describe('check `connection` resolver props', () => {
     const rsv = userComposer.getResolver('connection');
-    const type = rsv.getType();
-    // $FlowFixMe
+    const type: any = rsv.getType();
     const tc = new TypeComposer(type);
 
     it('should exists', () => {
@@ -94,9 +95,8 @@ describe('composeWithRelay', () => {
         }
       }
     }`;
-    const result = await graphql(schema, query);
+    const result: any = await graphql(schema, query);
 
-    // $FlowFixMe
     expect(result.data.userConnection).toEqual({
       count: 15,
       pageInfo: {
@@ -149,9 +149,8 @@ describe('composeWithRelay', () => {
         }
       }
     }`;
-    const result = await graphql(schema, query);
+    const result: any = await graphql(schema, query);
 
-    // $FlowFixMe
     expect(result.data.userConnection).toEqual({
       count: 15,
       pageInfo: {
@@ -243,7 +242,7 @@ describe('composeWithRelay', () => {
   });
 
   it('should pass `countResolveParams` to top resolverParams', async () => {
-    let topResolveParams;
+    let topResolveParams: any = {};
 
     rootQueryTC.setField(
       'userConnection',
@@ -265,18 +264,18 @@ 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(
       'userConnection',
@@ -298,11 +297,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: 2,

src/__tests__/connectionResolver-test.js

@@ -20,17 +20,17 @@ describe('connectionResolver', () => {
     });
 
     it('should throw error if first arg is not TypeComposer', () => {
-      // $FlowFixMe
-      expect(() => prepareConnectionResolver(123)).toThrowError(
-        'should be instance of TypeComposer'
-      );
+      expect(() => {
+        const wrongArgs: any = [123];
+        prepareConnectionResolver(...wrongArgs);
+      }).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`'
-      );
+      expect(() => {
+        const wrongArgs: any = [userTypeComposer, {}];
+        prepareConnectionResolver(...wrongArgs);
+      }).toThrowError('should have option `opts.countResolverName`');
     });
 
     it('should throw error if resolver opts.countResolverName does not exists', () => {
@@ -44,22 +44,24 @@ describe('connectionResolver', () => {
     });
 
     it('should throw error if opts.findResolverName are empty', () => {
-      expect(() =>
-        // $FlowFixMe
-        prepareConnectionResolver(userTypeComposer, {
-          countResolverName: 'count',
-        })
-      ).toThrowError('should have option `opts.findResolverName`');
+      expect(() => {
+        const wrongArgs: any = [userTypeComposer, { countResolverName: 'count' }];
+        prepareConnectionResolver(...wrongArgs);
+      }).toThrowError('should have option `opts.findResolverName`');
     });
 
     it('should throw error if resolver opts.countResolverName does not exists', () => {
-      expect(() =>
-        prepareConnectionResolver(userTypeComposer, {
-          countResolverName: 'count',
-          findResolverName: 'findManyDoesNotExists',
-          sort: sortOptions,
-        })
-      ).toThrowError("does not have resolver with name 'findManyDoesNotExists'");
+      expect(() => {
+        const wrongArgs: any = [
+          userTypeComposer,
+          {
+            countResolverName: 'count',
+            findResolverName: 'findManyDoesNotExists',
+            sort: sortOptions,
+          },
+        ];
+        prepareConnectionResolver(...wrongArgs);
+      }).toThrowError("does not have resolver with name 'findManyDoesNotExists'");
     });
   });
 
@@ -73,34 +75,28 @@ describe('connectionResolver', () => {
     });
 
     it('should have type to be ConnectionType', () => {
-      // $FlowFixMe
-      expect(connectionResolver.type.name).toBe('UserConnection');
+      expect((connectionResolver.type: any).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(GraphQLString);
     });
 
     it('should have `before` arg', () => {
-      // $FlowFixMe
       expect(connectionResolver.getArg('before').type).toBe(GraphQLString);
     });
 
     it('should have `sort` arg', () => {
-      // $FlowFixMe
       expect(connectionResolver.getArg('sort').type.name).toBe('SortConnectionUserEnum');
     });
   });
@@ -276,11 +272,10 @@ describe('connectionResolver', () => {
     };
 
     it('should setup in resolveParams.rawQuery', () => {
-      const rp = {
+      const rp: any = {
         args: { filter: { id: 123 } },
       };
       prepareRawQuery(rp, sortConfig);
-      // $FlowFixMe
       expect(rp.rawQuery).toEqual({});
     });
 
@@ -304,26 +299,24 @@ describe('connectionResolver', () => {
     });
 
     it('should call afterCursorQuery if provided args.after', () => {
-      const rp = {
+      const rp: any = {
         args: {
           after: dataToCursor({ id: 123 }),
           sort: sortConfig,
         },
       };
       prepareRawQuery(rp, sortConfig);
-      // $FlowFixMe
       expect(rp.rawQuery).toEqual({ after: { id: 123 } });
     });
 
     it('should call beforeCursorQuery if provided args.before', () => {
-      const rp = {
+      const rp: any = {
         args: {
           before: dataToCursor({ id: 234 }),
           sort: sortConfig,
         },
       };
       prepareRawQuery(rp, sortConfig);
-      // $FlowFixMe
       expect(rp.rawQuery).toEqual({ before: { id: 234 } });
     });
 

src/connectionResolver.js

@@ -2,7 +2,7 @@
 /* eslint-disable no-param-reassign, no-use-before-define */
 
 import { Resolver, TypeComposer } from 'graphql-compose';
-import type { ResolveParams, ProjectionType } from 'graphql-compose';
+import type { ResolveParams, ProjectionType, ComposeFieldConfigArgumentMap } from 'graphql-compose';
 import type { GraphQLResolveInfo } from 'graphql-compose/lib/graphql';
 import { prepareConnectionType } from './types/connectionType';
 import { prepareSortType } from './types/sortInputType';
@@ -103,9 +103,9 @@ export function prepareConnectionResolver<TSource, TContext>(
   }
   const findManyResolve = findManyResolver.getResolve();
 
-  const additionalArgs = {};
+  const additionalArgs: ComposeFieldConfigArgumentMap = {};
   if (findManyResolver.hasArg('filter')) {
-    const filter = findManyResolver.getArg('filter');
+    const filter: any = findManyResolver.getArg('filter');
     if (filter) {
       additionalArgs.filter = filter;
     }

src/types/__tests__/connectionType-test.js

@@ -38,8 +38,7 @@ describe('types/connectionType.js', () => {
     });
 
     it('should have `ofType` property (like GraphQLList, GraphQLNonNull)', () => {
-      const edgeType = prepareEdgeType(userTypeComposer);
-      // $FlowFixMe
+      const edgeType: any = prepareEdgeType(userTypeComposer);
       expect(edgeType.ofType).toEqual(userTypeComposer.getType());
     });
 
@@ -78,16 +77,14 @@ describe('types/connectionType.js', () => {
       expect(tc.getFieldType('edges')).toBeInstanceOf(GraphQLNonNull);
       expect(tc.getFieldType('edges').ofType).toBeInstanceOf(GraphQLList);
 
-      const edges = getNamedType(tc.getFieldType('edges'));
-      // $FlowFixMe
+      const edges: any = getNamedType(tc.getFieldType('edges'));
       expect(edges.name).toEqual('UserEdge');
     });
 
     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 = prepareConnectionType(userTypeComposer);
-      // $FlowFixMe
+      const connectionType: any = prepareConnectionType(userTypeComposer);
       expect(connectionType.ofType).toEqual(userTypeComposer.getType());
     });