Introduce formal definition of "Thunk" to aid in fixing more issues uncovered by Flow v0.28

Author: leebyron

src/execution/execute.js

@@ -594,7 +594,7 @@ function resolveField(
 // Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
 // function. Returns the result of resolveFn or the abrupt-return Error object.
 function resolveOrError(
-  resolveFn: GraphQLFieldResolveFn,
+  resolveFn: GraphQLFieldResolveFn<*>,
   source: mixed,
   args: { [key: string]: mixed },
   context: mixed,

src/type/definition.js

@@ -187,6 +187,17 @@ export function getNamedType(type: ?GraphQLType): ?GraphQLNamedType {
 }
 
 
+/**
+ * Used while defining GraphQL types to allow for circular references in
+ * otherwise immutable type definitions.
+ */
+export type Thunk<T> = (() => T) | T;
+
+function resolveThunk<T>(thunk: Thunk<T>): T {
+  return typeof thunk === 'function' ? thunk() : thunk;
+}
+
+
 /**
  * Scalar Type Definition
  *
@@ -204,13 +215,13 @@ export function getNamedType(type: ?GraphQLType): ?GraphQLNamedType {
  *     });
  *
  */
-export class GraphQLScalarType<InternalType> {
+export class GraphQLScalarType<TInternal, TExternal> {
   name: string;
   description: ?string;
 
-  _scalarConfig: GraphQLScalarTypeConfig<InternalType>;
+  _scalarConfig: GraphQLScalarTypeConfig<TInternal, TExternal>;
 
-  constructor(config: GraphQLScalarTypeConfig<InternalType>) {
+  constructor(config: GraphQLScalarTypeConfig<TInternal, TExternal>) {
     invariant(config.name, 'Type must be named.');
     assertValidName(config.name);
     this.name = config.name;
@@ -232,17 +243,17 @@ export class GraphQLScalarType<InternalType> {
     this._scalarConfig = config;
   }
 
-  serialize(value: InternalType): mixed {
+  serialize(value: TInternal): ?TExternal {
     const serializer = this._scalarConfig.serialize;
     return serializer(value);
   }
 
-  parseValue(value: mixed): ?InternalType {
+  parseValue(value: TExternal): ?TInternal {
     const parser = this._scalarConfig.parseValue;
     return parser ? parser(value) : null;
   }
 
-  parseLiteral(valueAST: Value): ?InternalType {
+  parseLiteral(valueAST: Value): ?TInternal {
     const parser = this._scalarConfig.parseLiteral;
     return parser ? parser(valueAST) : null;
   }
@@ -252,12 +263,12 @@ export class GraphQLScalarType<InternalType> {
   }
 }
 
-export type GraphQLScalarTypeConfig<InternalType> = {
+export type GraphQLScalarTypeConfig<TInternal, TExternal> = {
   name: string;
   description?: ?string;
-  serialize: (value: mixed) => ?InternalType;
-  parseValue?: (value: mixed) => ?InternalType;
-  parseLiteral?: (valueAST: Value) => ?InternalType;
+  serialize: (value: TInternal) => ?TExternal;
+  parseValue?: (value: TExternal) => ?TInternal;
+  parseLiteral?: (valueAST: Value) => ?TInternal;
 }
 
 
@@ -304,11 +315,11 @@ export class GraphQLObjectType {
   description: ?string;
   isTypeOf: ?GraphQLIsTypeOfFn;
 
-  _typeConfig: GraphQLObjectTypeConfig;
+  _typeConfig: GraphQLObjectTypeConfig<*>;
   _fields: GraphQLFieldDefinitionMap;
   _interfaces: Array<GraphQLInterfaceType>;
 
-  constructor(config: GraphQLObjectTypeConfig) {
+  constructor(config: GraphQLObjectTypeConfig<*>) {
     invariant(config.name, 'Type must be named.');
     assertValidName(config.name);
     this.name = config.name;
@@ -340,15 +351,11 @@ export class GraphQLObjectType {
   }
 }
 
-function resolveMaybeThunk<T>(thingOrThunk: T | () => T): T {
-  return typeof thingOrThunk === 'function' ? thingOrThunk() : thingOrThunk;
-}
-
 function defineInterfaces(
   type: GraphQLObjectType,
-  interfacesOrThunk: Array<GraphQLInterfaceType> | ?GraphQLInterfacesThunk
+  interfacesThunk: Thunk<?Array<GraphQLInterfaceType>>
 ): Array<GraphQLInterfaceType> {
-  const interfaces = resolveMaybeThunk(interfacesOrThunk);
+  const interfaces = resolveThunk(interfacesThunk);
   if (!interfaces) {
     return [];
   }
@@ -378,9 +385,9 @@ function defineInterfaces(
 
 function defineFieldMap(
   type: GraphQLNamedType,
-  fields: GraphQLFieldConfigMap | GraphQLFieldConfigMapThunk
+  fieldsThunk: Thunk<GraphQLFieldConfigMap<*>>
 ): GraphQLFieldDefinitionMap {
-  const fieldMap: any = resolveMaybeThunk(fields);
+  const fieldMap = resolveThunk(fieldsThunk);
   invariant(
     isPlainObj(fieldMap),
     `${type.name} fields must be an object with field names as keys or a ` +
@@ -397,8 +404,9 @@ function defineFieldMap(
   const resultFieldMap = {};
   fieldNames.forEach(fieldName => {
     assertValidName(fieldName);
+    const fieldConfig = fieldMap[fieldName];
     const field = {
-      ...fieldMap[fieldName],
+      ...fieldConfig,
       name: fieldName
     };
     invariant(
@@ -411,17 +419,18 @@ function defineFieldMap(
       `${type.name}.${fieldName} field type must be Output Type but ` +
       `got: ${String(field.type)}.`
     );
-    if (!field.args) {
+    const argsConfig = fieldConfig.args;
+    if (!argsConfig) {
       field.args = [];
     } else {
       invariant(
-        isPlainObj(field.args),
+        isPlainObj(argsConfig),
         `${type.name}.${fieldName} args must be an object with argument ` +
         'names as keys.'
       );
-      field.args = Object.keys(field.args).map(argName => {
+      field.args = Object.keys(argsConfig).map(argName => {
         assertValidName(argName);
-        const arg = field.args[argName];
+        const arg = argsConfig[argName];
         invariant(
           isInputType(arg.type),
           `${type.name}.${fieldName}(${argName}:) argument type must be ` +
@@ -444,32 +453,28 @@ function isPlainObj(obj) {
   return obj && typeof obj === 'object' && !Array.isArray(obj);
 }
 
-export type GraphQLObjectTypeConfig = {
+export type GraphQLObjectTypeConfig<TSource> = {
   name: string;
-  interfaces?: GraphQLInterfacesThunk | Array<GraphQLInterfaceType>;
-  fields: GraphQLFieldConfigMapThunk | GraphQLFieldConfigMap;
-  isTypeOf?: GraphQLIsTypeOfFn;
+  interfaces?: Thunk<?Array<GraphQLInterfaceType>>;
+  fields: Thunk<GraphQLFieldConfigMap<TSource>>;
+  isTypeOf?: ?GraphQLIsTypeOfFn;
   description?: ?string
 }
 
-type GraphQLInterfacesThunk = () => Array<GraphQLInterfaceType>;
-
-type GraphQLFieldConfigMapThunk = () => GraphQLFieldConfigMap;
-
 export type GraphQLTypeResolveFn = (
   value: mixed,
   context: mixed,
   info: GraphQLResolveInfo
 ) => ?GraphQLObjectType
 
 export type GraphQLIsTypeOfFn = (
-  value: mixed,
+  source: mixed,
   context: mixed,
   info: GraphQLResolveInfo
 ) => boolean
 
-export type GraphQLFieldResolveFn = (
-  source: mixed,
+export type GraphQLFieldResolveFn<TSource> = (
+  source: TSource,
   args: {[argName: string]: mixed},
   context: mixed,
   info: GraphQLResolveInfo
@@ -488,10 +493,10 @@ export type GraphQLResolveInfo = {
   variableValues: { [variableName: string]: mixed };
 }
 
-export type GraphQLFieldConfig = {
+export type GraphQLFieldConfig<TSource> = {
   type: GraphQLOutputType;
   args?: GraphQLFieldConfigArgumentMap;
-  resolve?: GraphQLFieldResolveFn;
+  resolve?: GraphQLFieldResolveFn<TSource>;
   deprecationReason?: ?string;
   description?: ?string;
 }
@@ -506,16 +511,16 @@ export type GraphQLArgumentConfig = {
   description?: ?string;
 }
 
-export type GraphQLFieldConfigMap = {
-  [fieldName: string]: GraphQLFieldConfig;
+export type GraphQLFieldConfigMap<TSource> = {
+  [fieldName: string]: GraphQLFieldConfig<TSource>;
 };
 
 export type GraphQLFieldDefinition = {
   name: string;
   description: ?string;
   type: GraphQLOutputType;
   args: Array<GraphQLArgument>;
-  resolve?: GraphQLFieldResolveFn;
+  resolve?: GraphQLFieldResolveFn<*>;
   deprecationReason?: ?string;
 }
 
@@ -585,13 +590,13 @@ export class GraphQLInterfaceType {
 
 export type GraphQLInterfaceTypeConfig = {
   name: string,
-  fields: GraphQLFieldConfigMapThunk | GraphQLFieldConfigMap,
+  fields: Thunk<GraphQLFieldConfigMap<mixed>>,
   /**
    * Optionally provide a custom type resolver function. If one is not provided,
    * the default implementation will call `isTypeOf` on each implementing
    * Object type.
    */
-  resolveType?: GraphQLTypeResolveFn,
+  resolveType?: ?GraphQLTypeResolveFn,
   description?: ?string
 };
 
@@ -880,7 +885,7 @@ export class GraphQLInputObjectType {
   }
 
   _defineFieldMap(): InputObjectFieldMap {
-    const fieldMap: any = resolveMaybeThunk(this._typeConfig.fields);
+    const fieldMap: any = resolveThunk(this._typeConfig.fields);
     invariant(
       isPlainObj(fieldMap),
       `${this.name} fields must be an object with field names as keys or a ` +
@@ -916,12 +921,10 @@ export class GraphQLInputObjectType {
 
 export type InputObjectConfig = {
   name: string;
-  fields: InputObjectConfigFieldMapThunk | InputObjectConfigFieldMap;
+  fields: Thunk<InputObjectConfigFieldMap>;
   description?: ?string;
 }
 
-export type InputObjectConfigFieldMapThunk = () => InputObjectConfigFieldMap;
-
 export type InputObjectFieldConfig = {
   type: GraphQLInputType;
   defaultValue?: mixed;

src/type/scalars.js

@@ -19,13 +19,12 @@ import { Kind } from '../language';
 const MAX_INT = 2147483647;
 const MIN_INT = -2147483648;
 
-function coerceInt(value) {
+function coerceInt(value: number): ?number {
   const num = Number(value);
   if (num === num && num <= MAX_INT && num >= MIN_INT) {
     return (num < 0 ? Math.ceil : Math.floor)(num);
   }
   return null;
-
 }
 
 export const GraphQLInt = new GraphQLScalarType({
@@ -46,7 +45,7 @@ export const GraphQLInt = new GraphQLScalarType({
   }
 });
 
-function coerceFloat(value) {
+function coerceFloat(value: number): ?number {
   const num = Number(value);
   return num === num ? num : null;
 }

src/utilities/buildASTSchema.js

@@ -92,11 +92,6 @@ import type {
 } from '../type/definition';
 
 
-type CompositeDefinition =
-  ObjectTypeDefinition |
-  InterfaceTypeDefinition |
-  UnionTypeDefinition;
-
 function buildWrappedType(
   innerType: GraphQLType,
   inputTypeAST: Type
@@ -259,9 +254,9 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
     return new GraphQLDirective({
       name: directiveAST.name.value,
       locations: directiveAST.locations.map(
-        node => (node.value: DirectiveLocationEnum)
+        node => ((node.value: any): DirectiveLocationEnum)
       ),
-      args: makeInputValues(directiveAST.arguments),
+      args: directiveAST.arguments && makeInputValues(directiveAST.arguments),
     });
   }
 
@@ -274,12 +269,24 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
     return (type: any);
   }
 
-  function produceTypeDef(typeAST: Type): GraphQLType {
+  function produceType(typeAST: Type): GraphQLType {
     const typeName = getNamedTypeAST(typeAST).name.value;
     const typeDef = typeDefNamed(typeName);
     return buildWrappedType(typeDef, typeAST);
   }
 
+  function produceObjectType(typeAST: Type): GraphQLObjectType {
+    const type = produceType(typeAST);
+    invariant(type instanceof GraphQLObjectType, 'Expected Object type.');
+    return type;
+  }
+
+  function produceInterfaceType(typeAST: Type): GraphQLInterfaceType {
+    const type = produceType(typeAST);
+    invariant(type instanceof GraphQLInterfaceType, 'Expected Object type.');
+    return type;
+  }
+
   function typeDefNamed(typeName: string): GraphQLNamedType {
     if (innerTypeMap[typeName]) {
       return innerTypeMap[typeName];
@@ -329,28 +336,31 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
     return new GraphQLObjectType(config);
   }
 
-  function makeFieldDefMap(def: CompositeDefinition) {
+  function makeFieldDefMap(
+    def: ObjectTypeDefinition | InterfaceTypeDefinition
+  ) {
     return keyValMap(
       def.fields,
       field => field.name.value,
       field => ({
-        type: produceTypeDef(field.type),
+        type: produceType(field.type),
         args: makeInputValues(field.arguments),
         deprecationReason: getDeprecationReason(field.directives)
       })
     );
   }
 
   function makeImplementedInterfaces(def: ObjectTypeDefinition) {
-    return def.interfaces.map(inter => produceTypeDef(inter));
+    return def.interfaces &&
+      def.interfaces.map(iface => produceInterfaceType(iface));
   }
 
   function makeInputValues(values: Array<InputValueDefinition>) {
     return keyValMap(
       values,
       value => value.name.value,
       value => {
-        const type = produceTypeDef(value.type);
+        const type = produceType(value.type);
         return { type, defaultValue: valueFromAST(value.defaultValue, type) };
       }
     );
@@ -385,7 +395,7 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
     return new GraphQLUnionType({
       name: def.name.value,
       resolveType: () => null,
-      types: def.types.map(t => produceTypeDef(t)),
+      types: def.types.map(t => produceObjectType(t)),
     });
   }
 

src/utilities/buildClientSchema.js

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