Add runtime check for resolve() related params.

According to type assuming between GraphQL v0.6.0 and Relay.

Author: iamchenxin

src/mutation/__tests__/mutation.js

@@ -65,6 +65,7 @@ var simpleRootValueMutation = mutationWithClientMutationId({
       type: GraphQLInt
     }
   },
+  // $FlowFixMe: check if Relay narrowed GraphQLResolveInfo.rootValue to Object
   mutateAndGetPayload: (params, context, {rootValue}) => (rootValue)
 });
 
@@ -384,5 +385,13 @@ describe('mutationWithClientMutationId()', () => {
 
       return expect(graphql(schema, query)).to.become({data: expected});
     });
+
+    it('must get a args.input:Object from GraphQL', () => {
+      const args = {input: 'wrongType'};
+      return expect(()=>{
+        (simpleMutationWithThunkFields:any).resolve({},args,{},{});
+      }).to.throw('args.input must be string,' +
+      ' but its wrongType(type: string)');
+    });
   });
 });

src/mutation/mutation.js

@@ -23,7 +23,7 @@ import type {
 } from 'graphql';
 
 type mutationFn = (object: Object, ctx: mixed, info: GraphQLResolveInfo) =>
-  ( Object | Promise<Object> );
+    ( Object | Promise<Object> );
 
 function resolveMaybeThunk<T>(thingOrThunk: T | () => T): T {
   return typeof thingOrThunk === 'function' ? thingOrThunk() : thingOrThunk;
@@ -86,7 +86,14 @@ export function mutationWithClientMutationId(
     args: {
       input: {type: new GraphQLNonNull(inputType)}
     },
-    resolve: (_, {input}, context, info) => {
+    resolve: (_, args, context, info) => {
+      // ToDo: Should make a static flow check later
+      // runtime check GraphQL(mixed) -> Relay(Object)
+      const input:Object = ( args.input instanceof Object) ? args.input
+        : (()=>{
+          throw new Error('args.input must be string,' +
+          ` but its ${args.input}(type: ${typeof args.input})`);
+        })();
       return Promise.resolve(mutateAndGetPayload(input, context, info))
         .then(payload => {
           payload.clientMutationId = input.clientMutationId;

src/node/__tests__/node.js

@@ -22,7 +22,8 @@ import {
 } from 'graphql';
 
 import {
-  nodeDefinitions
+  nodeDefinitions,
+  globalIdField
 } from '../node';
 
 var userData = {
@@ -239,6 +240,39 @@ describe('Node interface and fields', () => {
     });
   });
 
+  describe('reliability (#runtime check)', () => {
+    it('nodeField.resolve() will throw a error, ' +
+    'when receieve a non-string args.id from GraphQL', () => {
+      const id = 4;
+      return expect(()=>{
+        (nodeField:any).resolve({},{id: 4},{},{});
+      }).to.throw(`args.id must be string,but its ${id}` +
+        `(type: ${typeof id})` );
+    });
+
+    it('globalIdField() will throw a error, ' +
+      'when receieve a !(string|number) id from upstream', () => {
+      const gIdFielfConfig = globalIdField('test');
+      const id = {test: 4};
+      return expect(()=>{
+        (gIdFielfConfig:any).resolve({id: id},{},{},{});
+      }).to.throw('id field must be string|number, ' +
+      'but it is [object Object](type: object)');
+    });
+
+    // most of this case must be caused by user's wrong typo.
+    it('globalIdField() will throw a error, when the user custom idFetcher ' +
+      'return a !(string|number) id', () => {
+      const source = {customId: '2'};
+      // do a wrong typo customId vs customid
+      const gIdFielfConfig = globalIdField('test',src => src.customid);
+      return expect(()=>{
+        (gIdFielfConfig:any).resolve(source,{},{},{});
+      }).to.throw('globalIdField.idFetcher must return a string|number, ' +
+      'check your code.');
+    });
+  });
+
   describe('introspection', () => {
     it('has correct node interface', () => {
       var query = `{

src/node/__tests__/plural.js

@@ -40,20 +40,22 @@ var userType = new GraphQLObjectType({
   }),
 });
 
+var pluralRootField = pluralIdentifyingRootField({
+  argName: 'usernames',
+  description: 'Map from a username to the user',
+  inputType: GraphQLString,
+  outputType: userType,
+  // $FlowFixMe : rootValue Graphql(mixed) -> relay(object)
+  resolveSingleInput: (username, context, {rootValue: {lang}}) => ({
+    username: username,
+    url: 'www.facebook.com/' + username + '?lang=' + lang
+  }),
+});
+
 var queryType = new GraphQLObjectType({
   name: 'Query',
   fields: () => ({
-    usernames: pluralIdentifyingRootField({
-      argName: 'usernames',
-      description: 'Map from a username to the user',
-      inputType: GraphQLString,
-      outputType: userType,
-      // $FlowFixMe : rootValue Graphql(mixed) -> relay(object)
-      resolveSingleInput: (username, context, {rootValue: {lang}}) => ({
-        username: username,
-        url: 'www.facebook.com/' + username + '?lang=' + lang
-      })
-    })
+    usernames: pluralRootField
   })
 });
 
@@ -163,6 +165,13 @@ describe('pluralIdentifyingRootField()', () => {
 
     return expect(graphql(schema, query)).to.become({data: expected});
   });
+
+  it('only accept Array<> args from GraphQL', () => {
+    return expect(()=>{
+      (pluralRootField:any).resolve({},{usernames: 'test'},{},{});
+    }).to.throw('plural\'s inputArgs must be Array,' +
+    ' but its test(type: string)');
+  });
 });
 
 describe('nonNull()', () => {

src/node/node.js

@@ -68,7 +68,17 @@ export function nodeDefinitions(
         description: 'The ID of an object'
       }
     },
-    resolve: (obj, {id}, context, info) => idFetcher(id, context, info),
+    resolve: (obj, args, context, info) => {
+      // ToDo : should make static flow check later
+      // graphql should pass a args.id(GraphQLID) in.
+      // which always serialize to a string in graphql v0.6
+      const id:string = (typeof args.id === 'string') ? args.id
+        : (()=>{
+          throw new Error(`args.id must be string,but its ${args.id}` +
+            `(type: ${typeof args.id})`);
+        })();
+      return idFetcher(id, context, info);
+    },
   };
 
   return {nodeInterface, nodeField};
@@ -108,15 +118,37 @@ export function fromGlobalId(globalId: string): ResolvedGlobalId {
  */
 export function globalIdField(
   typeName?: ?string,
-  idFetcher?: (object: any, context: any, info: GraphQLResolveInfo) => string
+  idFetcher?: (object: Object, context: mixed,
+    info: GraphQLResolveInfo) => string
 ): GraphQLFieldConfig {
   return {
     name: 'id',
     description: 'The ID of an object',
     type: new GraphQLNonNull(GraphQLID),
-    resolve: (obj, args, context, info) => toGlobalId(
-      typeName || info.parentType.name,
-      idFetcher ? idFetcher(obj, context, info) : obj.id
-    )
+    resolve: (source, args, context, info) => {
+      // ToDo : should make static flow check later
+      // runtime check for GraphQLNonNull(GraphQLID) : string|number
+      if ( idFetcher ) {
+        let id = check( idFetcher((source:any), context, info),
+        'globalIdField.idFetcher must return a string|number, ' +
+        'check your code.');
+        return toGlobalId(typeName || info.parentType.name, id);
+      } else {
+        let id = check( (source:any).id, 'id field must be string|number, ' +
+        `but it is ${(source:any).id}(type: ${typeof (source:any).id})`);
+        return toGlobalId(typeName || info.parentType.name, id);
+      }
+
+      function check(unId:any,eMsg:string):string {
+        switch (typeof unId) {
+          case 'string':
+            return unId;
+          case 'number':
+            return unId.toString();
+          default:
+            throw new Error(eMsg);
+        }
+      }
+    }
   };
 }

src/node/plural.js

@@ -48,7 +48,14 @@ export function pluralIdentifyingRootField(
     type: new GraphQLList(config.outputType),
     args: inputArgs,
     resolve: (obj, args, context, info) => {
-      var inputs = args[config.argName];
+      const uncheckedInputs = args[config.argName];
+      // ToDo : should make static flow check later
+      // runtime check for args[config.argName] : Array<mixed>
+      const inputs = Array.isArray(uncheckedInputs) ? uncheckedInputs
+        : (()=>{
+          throw new Error('plural\'s inputArgs must be Array, but its' +
+          ` ${uncheckedInputs}(type: ${typeof uncheckedInputs})`);
+        })();
       return Promise.all(inputs.map(
         input => Promise.resolve(
           config.resolveSingleInput(input, context, info)