Additional flow issues corrected in anticipation of Flow v0.28

Author: leebyron

src/type/definition.js

@@ -232,7 +232,7 @@ export class GraphQLScalarType<InternalType> {
     this._scalarConfig = config;
   }
 
-  serialize(value: mixed): ?InternalType {
+  serialize(value: InternalType): mixed {
     const serializer = this._scalarConfig.serialize;
     return serializer(value);
   }
@@ -361,7 +361,7 @@ function defineInterfaces(
     invariant(
       iface instanceof GraphQLInterfaceType,
       `${type.name} may only implement Interface types, it cannot ` +
-      `implement: ${iface.name}.`
+      `implement: ${String(iface)}.`
     );
     if (typeof iface.resolveType !== 'function') {
       invariant(

src/type/directives.js

@@ -78,7 +78,7 @@ export class GraphQLDirective {
         invariant(
           isInputType(arg.type),
           `@${config.name}(${argName}:) argument type must be ` +
-          `Input Type but got: ${arg.type}.`
+          `Input Type but got: ${String(arg.type)}.`
         );
         return {
           name: argName,

src/type/schema.js

@@ -68,27 +68,28 @@ export class GraphQLSchema {
 
     invariant(
       config.query instanceof GraphQLObjectType,
-      `Schema query must be Object Type but got: ${config.query}.`
+      `Schema query must be Object Type but got: ${
+        String(config.query)}.`
     );
     this._queryType = config.query;
 
     invariant(
       !config.mutation || config.mutation instanceof GraphQLObjectType,
       `Schema mutation must be Object Type if provided but got: ${
-        config.mutation}.`
+        String(config.mutation)}.`
     );
     this._mutationType = config.mutation;
 
     invariant(
       !config.subscription || config.subscription instanceof GraphQLObjectType,
       `Schema subscription must be Object Type if provided but got: ${
-        config.subscription}.`
+        String(config.subscription)}.`
     );
     this._subscriptionType = config.subscription;
 
     invariant(
       !config.types || Array.isArray(config.types),
-      `Schema types must be Array if provided but got: ${config.types}.`
+      `Schema types must be Array if provided but got: ${String(config.types)}.`
     );
 
     invariant(
@@ -97,7 +98,7 @@ export class GraphQLSchema {
         directive => directive instanceof GraphQLDirective
       ),
       `Schema directives must be Array<GraphQLDirective> if provided but got: ${
-        config.directives}.`
+        String(config.directives)}.`
     );
     // Provide specified directives (e.g. @include and @skip) by default.
     this._directives = config.directives || specifiedDirectives;
@@ -190,8 +191,8 @@ export class GraphQLSchema {
       const possibleTypes = this.getPossibleTypes(abstractType);
       invariant(
         Array.isArray(possibleTypes),
-        `Could not find possible implementing types for ${abstractType} in ` +
-        'schema. Check that schema.types is defined and is an array of ' +
+        `Could not find possible implementing types for ${abstractType.name} ` +
+        'in schema. Check that schema.types is defined and is an array of ' +
         'all possible types in the schema.'
       );
       possibleTypeMap[abstractType.name] =
@@ -234,7 +235,7 @@ function typeMapReducer(map: TypeMap, type: ?GraphQLType): TypeMap {
     invariant(
       map[type.name] === type,
       'Schema must contain unique named types but contains multiple ' +
-      `types named "${type}".`
+      `types named "${type.name}".`
     );
     return map;
   }

src/utilities/buildASTSchema.js

@@ -71,6 +71,10 @@ import {
   GraphQLDeprecatedDirective,
 } from '../type/directives';
 
+import type {
+  DirectiveLocationEnum
+} from '../type/directives';
+
 import {
   __Schema,
   __Directive,
@@ -254,7 +258,9 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
   function getDirective(directiveAST: DirectiveDefinition): GraphQLDirective {
     return new GraphQLDirective({
       name: directiveAST.name.value,
-      locations: directiveAST.locations.map(node => node.value),
+      locations: directiveAST.locations.map(
+        node => (node.value: DirectiveLocationEnum)
+      ),
       args: makeInputValues(directiveAST.arguments),
     });
   }

src/utilities/buildClientSchema.js

@@ -222,7 +222,7 @@ export function buildClientSchema(
 
   function buildScalarDef(
     scalarIntrospection: IntrospectionScalarType
-  ): GraphQLScalarType {
+  ): GraphQLScalarType<boolean> {
     return new GraphQLScalarType({
       name: scalarIntrospection.name,
       description: scalarIntrospection.description,

src/utilities/extendSchema.js

@@ -185,17 +185,17 @@ export function extendSchema(
     __TypeKind,
   };
 
-  // Get the root Query, Mutation, and Subscription types.
-  const queryType = getTypeFromDef(schema.getQueryType());
+  // Get the root Query, Mutation, and Subscription object types.
+  const queryType = getObjectTypeFromDef(schema.getQueryType());
 
   const existingMutationType = schema.getMutationType();
   const mutationType = existingMutationType ?
-    getTypeFromDef(existingMutationType) :
+    getObjectTypeFromDef(existingMutationType) :
     null;
 
   const existingSubscriptionType = schema.getSubscriptionType();
   const subscriptionType = existingSubscriptionType ?
-    getTypeFromDef(existingSubscriptionType) :
+    getObjectTypeFromDef(existingSubscriptionType) :
     null;
 
   // Iterate through all types, getting the type definition for each, ensuring
@@ -228,6 +228,12 @@ export function extendSchema(
     return type;
   }
 
+  function getObjectTypeFromDef(typeDef: GraphQLObjectType): GraphQLObjectType {
+    const type = _getNamedType(typeDef.name);
+    invariant(type instanceof GraphQLObjectType, 'Invalid schema');
+    return type;
+  }
+
   function getTypeFromAST(astNode: NamedType): GraphQLNamedType {
     const type = _getNamedType(astNode.name.value);
     if (!type) {
@@ -302,7 +308,7 @@ export function extendSchema(
     return new GraphQLUnionType({
       name: type.name,
       description: type.description,
-      types: type.getTypes().map(getTypeFromDef),
+      types: type.getTypes().map(getObjectTypeFromDef),
       resolveType: cannotExecuteClientSchema,
     });
   }

src/utilities/schemaPrinter.js

@@ -82,17 +82,17 @@ function printSchemaDefinition(schema: GraphQLSchema): string {
 
   const queryType = schema.getQueryType();
   if (queryType) {
-    operationTypes.push(`  query: ${queryType}`);
+    operationTypes.push(`  query: ${queryType.name}`);
   }
 
   const mutationType = schema.getMutationType();
   if (mutationType) {
-    operationTypes.push(`  mutation: ${mutationType}`);
+    operationTypes.push(`  mutation: ${mutationType.name}`);
   }
 
   const subscriptionType = schema.getSubscriptionType();
   if (subscriptionType) {
-    operationTypes.push(`  subscription: ${subscriptionType}`);
+    operationTypes.push(`  subscription: ${subscriptionType.name}`);
   }
 
   return `schema {\n${operationTypes.join('\n')}\n}`;
@@ -114,7 +114,7 @@ function printType(type: GraphQLType): string {
   return printInputObject(type);
 }
 
-function printScalar(type: GraphQLScalarType): string {
+function printScalar(type: GraphQLScalarType<any>): string {
   return `scalar ${type.name}`;
 }
 
@@ -156,7 +156,8 @@ function printFields(type) {
   const fieldMap = type.getFields();
   const fields = Object.keys(fieldMap).map(fieldName => fieldMap[fieldName]);
   return fields.map(
-    f => `  ${f.name}${printArgs(f)}: ${f.type}${printDeprecated(f)}`
+    f => '  ' + f.name + printArgs(f) + ': ' +
+      String(f.type) + printDeprecated(f)
   ).join('\n');
 }
 
@@ -182,7 +183,7 @@ function printArgs(fieldOrDirectives) {
 }
 
 function printInputValue(arg) {
-  let argDecl = `${arg.name}: ${arg.type}`;
+  let argDecl = arg.name + ': ' + String(arg.type);
   if (!isNullish(arg.defaultValue)) {
     argDecl += ` = ${print(astFromValue(arg.defaultValue, arg.type))}`;
   }

src/validation/rules/DefaultValuesOfCorrectType.js

@@ -21,8 +21,9 @@ export function defaultForNonNullArgMessage(
   type: GraphQLType,
   guessType: GraphQLType
 ): string {
-  return `Variable "$${varName}" of type "${type}" is required and will not ` +
-    `use the default value. Perhaps you meant to use type "${guessType}".`;
+  return `Variable "$${varName}" of type "${String(type)}" is required and ` +
+    'will not use the default value. ' +
+    `Perhaps you meant to use type "${String(guessType)}".`;
 }
 
 export function badValueForDefaultArgMessage(
@@ -32,7 +33,8 @@ export function badValueForDefaultArgMessage(
   verboseErrors?: [string]
 ): string {
   const message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
-  return `Variable "$${varName}" has invalid default value ${value}.${message}`;
+  return `Variable "$${varName}" of type "${String(type)}" has invalid ` +
+    `default value ${value}.${message}`;
 }
 
 /**

src/validation/rules/FragmentsOnCompositeTypes.js

@@ -18,15 +18,15 @@ import type { GraphQLType } from '../../type/definition';
 export function inlineFragmentOnNonCompositeErrorMessage(
   type: GraphQLType
 ): string {
-  return `Fragment cannot condition on non composite type "${type}".`;
+  return `Fragment cannot condition on non composite type "${String(type)}".`;
 }
 
 export function fragmentOnNonCompositeErrorMessage(
   fragName: string,
   type: GraphQLType
 ): string {
   return `Fragment "${fragName}" cannot condition on non composite ` +
-    `type "${type}".`;
+    `type "${String(type)}".`;
 }
 
 /**

src/validation/rules/KnownArgumentNames.js

@@ -28,7 +28,7 @@ export function unknownArgMessage(
   suggestedArgs: Array<string>
 ): string {
   let message = `Unknown argument "${argName}" on field "${fieldName}" of ` +
-    `type "${type}".`;
+    `type "${String(type)}".`;
   if (suggestedArgs.length) {
     message += ` Did you mean ${quotedOrList(suggestedArgs)}?`;
   }