fix(Flowtype): Resolve Flow warnings and other code style fixes

Author: nodkz

src/definition.js

@@ -10,7 +10,7 @@ import type {
   ResolverMWOutputTypeFn as _ResolverMWOutputTypeFn,
   ResolverMWOutputType as _ResolverMWOutputType,
   GraphQLResolveInfo as _GraphQLResolveInfo,
-} from 'graphql-compose/lib/definition.js';
+} from 'graphql-compose/lib/definition';
 
 import type {
   TypeComposer as _TypeComposer,
@@ -28,18 +28,18 @@ export type WrapMutationResolverOpts = {
 export type ResolverMWArgsFn = _ResolverMWArgsFn;
 export type ResolverMWArgs = _ResolverMWArgs;
 
-export type ResolverMWResolveFn = _ResolverMWResolveFn;
-export type ResolverMWResolve = _ResolverMWResolve;
+export type ResolverMWResolveFn<TSource, TContext> = _ResolverMWResolveFn<TSource, TContext>;
+export type ResolverMWResolve<TSource, TContext> = _ResolverMWResolve<TSource, TContext>;
 
 export type ResolverMWOutputTypeFn = _ResolverMWOutputTypeFn;
 export type ResolverMWOutputType = _ResolverMWOutputType;
 
 export type GraphQLResolveInfo = _GraphQLResolveInfo;
 
-export type Resolver = _Resolver;
-export type ResolveParams = _ResolveParams;
+export type Resolver<TSource, TContext> = _Resolver<TSource, TContext>;
+export type ResolveParams<TSource, TContext> = _ResolveParams<TSource, TContext>;
 export type TypeComposer = _TypeComposer;
-export type TypeMapForNode = {[typeName: string]: { resolver: Resolver, tc: TypeComposer } };
+export type TypeMapForNode = {[typeName: string]: { resolver: Resolver<*, *>, tc: TypeComposer } };
 
 
 // INTERNAL TYPES

src/globalId.js

@@ -3,7 +3,7 @@
 import type {
   ResolvedGlobalId,
   Base64String,
-} from './definition.js';
+} from './definition';
 
 export function base64(i: string): Base64String {
   return ((new Buffer(i, 'ascii')).toString('base64'));

src/nodeFieldConfig.js

@@ -5,8 +5,7 @@ import { GraphQLID, GraphQLNonNull } from 'graphql';
 import { getProjectionFromAST } from 'graphql-compose';
 import { fromGlobalId } from './globalId';
 import NodeInterface from './nodeInterface';
-import type { TypeMapForNode, GraphQLResolveInfo } from './definition.js';
-
+import type { TypeMapForNode, GraphQLResolveInfo } from './definition';
 
 // this fieldConfig must be set to RootQuery.node field
 export function getNodeFieldConfig(typeMapForNode: TypeMapForNode) {
@@ -21,9 +20,9 @@ export function getNodeFieldConfig(typeMapForNode: TypeMapForNode) {
     },
     resolve: (
       source: mixed,
-      args: {[argName: string]: mixed},
+      args: { [argName: string]: mixed },
       context: mixed,
-      info: GraphQLResolveInfo
+      info: GraphQLResolveInfo,
     ) => {
       if (!args.id || !(typeof args.id === 'string')) {
         return null;
@@ -51,17 +50,19 @@ export function getNodeFieldConfig(typeMapForNode: TypeMapForNode) {
 
         // suppose that first argument is argument with id field
         const idArgName = Object.keys(findById.args)[0];
-        return findById.resolve({
-          source,
-          args: { [idArgName]: id }, // eg. mongoose has _id fieldname, so should map
-          context,
-          info,
-          projection,
-        }).then(res => {
-          if (!res) return res;
-          res.__nodeType = graphqlType;
-          return res;
-        });
+        return findById
+          .resolve({
+            source,
+            args: { [idArgName]: id }, // eg. mongoose has _id fieldname, so should map
+            context,
+            info,
+            projection,
+          })
+          .then((res) => {
+            if (!res) return res;
+            res.__nodeType = graphqlType;
+            return res;
+          });
       }
 
       return null;

src/nodeInterface.js

@@ -18,7 +18,6 @@ const NodeInterface = new GraphQLInterfaceType({
   }),
   resolveType: (payload) => {
     // `payload.__nodeType` was added to payload via nodeFieldConfig.resolve
-    // $FlowFixMe
     return payload.__nodeType ? payload.__nodeType : null;
   },
 });

src/wrapMutationResolver.js

@@ -1,27 +1,19 @@
 /* @flow */
 /* eslint-disable no-param-reassign */
 
-import {
-  GraphQLObjectType,
-  getNamedType,
-  GraphQLInputObjectType,
-  GraphQLNonNull,
-} from 'graphql';
+import { GraphQLObjectType, getNamedType, GraphQLInputObjectType, GraphQLNonNull } from 'graphql';
 import { TypeComposer, InputTypeComposer } from 'graphql-compose';
 import { toGlobalId } from './globalId';
-import type {
-  Resolver,
-  WrapMutationResolverOpts,
-} from './definition';
+import type { Resolver, WrapMutationResolverOpts } from './definition';
 
 function upperFirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-export default function wrapMutationResolver(
-  resolver: Resolver,
-  opts: WrapMutationResolverOpts = {}
-): Resolver {
+export default function wrapMutationResolver<TSource, TContext>(
+  resolver: Resolver<TSource, TContext>,
+  opts: WrapMutationResolverOpts,
+): Resolver<TSource, TContext> {
   const { resolverName, rootTypeName } = opts;
 
   function prepareArgs(newResolver) {
@@ -44,15 +36,17 @@ export default function wrapMutationResolver(
           type: new GraphQLNonNull(ITC.getType()),
         },
       });
+      // $FlowFixMe
       newResolver._relayIsArgsWrapped = true;
     }
 
     // add `clientMutationId` to args.input field
     if (ITC && !ITC.hasField('clientMutationId')) {
       ITC.setField('clientMutationId', {
         type: 'String',
-        description: 'The client mutation ID used by clients like Relay to track the mutation. '
-                   + 'If given, returned in the response payload of the mutation.',
+        description:
+          'The client mutation ID used by clients like Relay to track the mutation. ' +
+            'If given, returned in the response payload of the mutation.',
       });
     }
   }
@@ -69,21 +63,16 @@ export default function wrapMutationResolver(
       }
 
       if (newResolver._relayIsArgsWrapped) {
-        // $FlowFixMe
         resolveParams.args = resolveParams.args.input;
       }
 
-      return prevResolver.resolve(resolveParams)
-        .then(res => {
-          res.nodeId = toGlobalId(
-            rootTypeName,
-            res.recordId
-          );
-          if (clientMutationId) {
-            res.clientMutationId = clientMutationId;
-          }
-          return res;
-        });
+      return prevResolver.resolve(resolveParams).then((res) => {
+        res.nodeId = toGlobalId(rootTypeName, res.recordId);
+        if (clientMutationId) {
+          res.clientMutationId = clientMutationId;
+        }
+        return res;
+      });
     });
   }
 
@@ -105,17 +94,22 @@ export default function wrapMutationResolver(
     if (!outputTC.hasField('clientMutationId')) {
       outputTC.setField('clientMutationId', {
         type: 'String',
-        description: 'The client mutation ID used by clients like Relay to track the mutation. '
-                   + 'If given, returned in the response payload of the mutation.',
+        description:
+          'The client mutation ID used by clients like Relay to track the mutation. ' +
+            'If given, returned in the response payload of the mutation.',
       });
     }
 
     newResolver.setType(outputTC.getType());
   }
 
-  return resolver.wrap((newResolver, prevResolver) => {
-    prepareArgs(newResolver);
-    prepareResolve(newResolver, prevResolver);
-    prepareType(newResolver, prevResolver);
-  }, { name: 'RelayMutation' });
+  return resolver.wrap(
+    (newResolver, prevResolver) => {
+      prepareArgs(newResolver);
+      prepareResolve(newResolver, prevResolver);
+      prepareType(newResolver, prevResolver);
+      return newResolver;
+    },
+    { name: 'RelayMutation' },
+  );
 }