Only type Scalar config rather than Scalar type, improve schema builder types

Author: leebyron

src/type/definition.js

@@ -215,13 +215,13 @@ function resolveThunk<T>(thunk: Thunk<T>): T {
  *     });
  *
  */
-export class GraphQLScalarType<TInternal, TExternal> {
+export class GraphQLScalarType {
   name: string;
   description: ?string;
 
-  _scalarConfig: GraphQLScalarTypeConfig<TInternal, TExternal>;
+  _scalarConfig: GraphQLScalarTypeConfig<*, *>;
 
-  constructor(config: GraphQLScalarTypeConfig<TInternal, TExternal>) {
+  constructor(config: GraphQLScalarTypeConfig<*, *>) {
     invariant(config.name, 'Type must be named.');
     assertValidName(config.name);
     this.name = config.name;
@@ -243,17 +243,20 @@ export class GraphQLScalarType<TInternal, TExternal> {
     this._scalarConfig = config;
   }
 
-  serialize(value: TInternal): ?TExternal {
+  // Serializes an internal value to include an a response.
+  serialize(value: mixed): mixed {
     const serializer = this._scalarConfig.serialize;
     return serializer(value);
   }
 
-  parseValue(value: TExternal): ?TInternal {
+  // Parses an externally provided value to use as an input.
+  parseValue(value: mixed): mixed {
     const parser = this._scalarConfig.parseValue;
     return parser ? parser(value) : null;
   }
 
-  parseLiteral(valueAST: Value): ?TInternal {
+  // Parses an externally provided literal value to use as an input.
+  parseLiteral(valueAST: Value): mixed {
     const parser = this._scalarConfig.parseLiteral;
     return parser ? parser(valueAST) : null;
   }
@@ -266,8 +269,8 @@ export class GraphQLScalarType<TInternal, TExternal> {
 export type GraphQLScalarTypeConfig<TInternal, TExternal> = {
   name: string;
   description?: ?string;
-  serialize: (value: TInternal) => ?TExternal;
-  parseValue?: (value: TExternal) => ?TInternal;
+  serialize: (value: mixed) => ?TExternal;
+  parseValue?: (value: mixed) => ?TInternal;
   parseLiteral?: (valueAST: Value) => ?TInternal;
 }
 

src/type/scalars.js

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

src/utilities/buildASTSchema.js

@@ -47,22 +47,35 @@ import type {
   DirectiveDefinition,
 } from '../language/ast';
 
+import { GraphQLSchema } from '../type/schema';
+
+import {
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLID,
+} from '../type/scalars';
+
 import {
-  GraphQLSchema,
   GraphQLScalarType,
   GraphQLObjectType,
   GraphQLInterfaceType,
   GraphQLUnionType,
   GraphQLEnumType,
   GraphQLInputObjectType,
-  GraphQLString,
-  GraphQLInt,
-  GraphQLFloat,
-  GraphQLBoolean,
-  GraphQLID,
   GraphQLList,
   GraphQLNonNull,
-} from '../type';
+  isInputType,
+  isOutputType,
+} from '../type/definition';
+
+import type {
+  GraphQLType,
+  GraphQLNamedType,
+  GraphQLInputType,
+  GraphQLOutputType,
+} from '../type/definition';
 
 import {
   GraphQLDirective,
@@ -86,11 +99,6 @@ import {
   __TypeKind,
 } from '../type/introspection';
 
-import type {
-  GraphQLType,
-  GraphQLNamedType
-} from '../type/definition';
-
 
 function buildWrappedType(
   innerType: GraphQLType,
@@ -275,6 +283,18 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
     return buildWrappedType(typeDef, typeAST);
   }
 
+  function produceInputType(typeAST: Type): GraphQLInputType {
+    const type = produceType(typeAST);
+    invariant(isInputType(type), 'Expected Input type.');
+    return (type: any);
+  }
+
+  function produceOutputType(typeAST: Type): GraphQLOutputType {
+    const type = produceType(typeAST);
+    invariant(isOutputType(type), 'Expected Output type.');
+    return (type: any);
+  }
+
   function produceObjectType(typeAST: Type): GraphQLObjectType {
     const type = produceType(typeAST);
     invariant(type instanceof GraphQLObjectType, 'Expected Object type.');
@@ -343,7 +363,7 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
       def.fields,
       field => field.name.value,
       field => ({
-        type: produceType(field.type),
+        type: produceOutputType(field.type),
         args: makeInputValues(field.arguments),
         deprecationReason: getDeprecationReason(field.directives)
       })
@@ -360,7 +380,7 @@ export function buildASTSchema(ast: Document): GraphQLSchema {
       values,
       value => value.name.value,
       value => {
-        const type = produceType(value.type);
+        const type = produceInputType(value.type);
         return { type, defaultValue: valueFromAST(value.defaultValue, type) };
       }
     );

src/utilities/buildClientSchema.js

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

src/utilities/extendSchema.js

@@ -24,6 +24,8 @@ import {
   GraphQLScalarType,
   GraphQLEnumType,
   GraphQLInputObjectType,
+  isInputType,
+  isOutputType,
 } from '../type/definition';
 
 import {
@@ -61,6 +63,8 @@ import {
 import type {
   GraphQLType,
   GraphQLNamedType,
+  GraphQLInputType,
+  GraphQLOutputType,
 } from '../type/definition';
 
 import type {
@@ -200,8 +204,9 @@ export function extendSchema(
 
   // Iterate through all types, getting the type definition for each, ensuring
   // that any type not directly referenced by a field will get created.
-  const types = Object.keys(schema.getTypeMap()).map(typeName =>
-    getTypeFromDef(schema.getType(typeName))
+  const typeMap = schema.getTypeMap();
+  const types = Object.keys(typeMap).map(typeName =>
+    getTypeFromDef(typeMap[typeName])
   );
 
   // Do the same with new types, appending to the list of defined types.
@@ -266,6 +271,18 @@ export function extendSchema(
     return type;
   }
 
+  function getInputTypeFromAST(astNode: NamedType): GraphQLInputType {
+    const type = getTypeFromAST(astNode);
+    invariant(isInputType(type), 'Must be Input type.');
+    return (type: any);
+  }
+
+  function getOutputTypeFromAST(astNode: NamedType): GraphQLOutputType {
+    const type = getTypeFromAST(astNode);
+    invariant(isOutputType(type), 'Must be Output type.');
+    return (type: any);
+  }
+
   // Given a name, returns a type from either the existing schema or an
   // added type.
   function _getNamedType(typeName: string): ?GraphQLNamedType {
@@ -387,7 +404,7 @@ export function extendSchema(
             );
           }
           newFieldMap[fieldName] = {
-            type: buildFieldType(field.type),
+            type: buildOutputFieldType(field.type),
             args: buildInputValues(field.arguments),
             resolve: cannotExecuteClientSchema,
           };
@@ -480,7 +497,7 @@ export function extendSchema(
       typeAST.fields,
       field => field.name.value,
       field => ({
-        type: buildFieldType(field.type),
+        type: buildOutputFieldType(field.type),
         args: buildInputValues(field.arguments),
         resolve: cannotExecuteClientSchema,
       })
@@ -492,7 +509,7 @@ export function extendSchema(
       values,
       value => value.name.value,
       value => {
-        const type = buildFieldType(value.type);
+        const type = buildInputFieldType(value.type);
         return {
           type,
           defaultValue: valueFromAST(value.defaultValue, type)
@@ -501,14 +518,24 @@ export function extendSchema(
     );
   }
 
-  function buildFieldType(typeAST: Type): GraphQLType {
+  function buildInputFieldType(typeAST: Type): GraphQLInputType {
+    if (typeAST.kind === LIST_TYPE) {
+      return new GraphQLList(buildInputFieldType(typeAST.type));
+    }
+    if (typeAST.kind === NON_NULL_TYPE) {
+      return new GraphQLNonNull(buildInputFieldType(typeAST.type));
+    }
+    return getInputTypeFromAST(typeAST);
+  }
+
+  function buildOutputFieldType(typeAST: Type): GraphQLOutputType {
     if (typeAST.kind === LIST_TYPE) {
-      return new GraphQLList(buildFieldType(typeAST.type));
+      return new GraphQLList(buildOutputFieldType(typeAST.type));
     }
     if (typeAST.kind === NON_NULL_TYPE) {
-      return new GraphQLNonNull(buildFieldType(typeAST.type));
+      return new GraphQLNonNull(buildOutputFieldType(typeAST.type));
     }
-    return getTypeFromAST(typeAST);
+    return getOutputTypeFromAST(typeAST);
   }
 }
 

src/utilities/schemaPrinter.js

@@ -114,7 +114,7 @@ function printType(type: GraphQLType): string {
   return printInputObject(type);
 }
 
-function printScalar(type: GraphQLScalarType<any, any>): string {
+function printScalar(type: GraphQLScalarType): string {
   return `scalar ${type.name}`;
 }