Update produceType.js

Author: migueloller

src/build/__tests__/produceType-test.js

@@ -1,4 +1,6 @@
+/* @flow */
 
+import { parse } from 'graphql/language';
 import {
   GraphQLScalarType,
   GraphQLInt,
@@ -8,60 +10,88 @@ import {
   GraphQLID,
   GraphQLList,
   GraphQLNonNull,
+  __Schema,
+  __Directive,
+  __DirectiveLocation,
+  __Type,
+  __Field,
+  __InputValue,
+  __EnumValue,
+  __TypeKind,
 } from 'graphql/type';
-import { parse } from 'graphql/language';
-import produceType, { getNamedTypeAST, buildWrappedType } from '../produceType';
+import produceType, { getNamedTypeNode, buildWrappedType } from '../produceType';
 
-const [{ type: innerTypeAST }, { type: wrappedTypeAST }] = parse(`
+const [{ type: wrappedTypeNode }, { type: wrapperTypeNode }] = (parse(`
   type Ints {
     int: Int
     nonNullListOfNonNullInt: [Int!]!
   }
-`, { noLocation: true }).definitions[0].fields;
+`, { noLocation: true }).definitions[0]: any).fields;
 const wrappedType = new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLInt)));
 
-describe('getNamedTypeAST()', () => {
-  it('should work', () => {
-    expect(getNamedTypeAST(wrappedTypeAST)).toEqual(innerTypeAST);
+describe('getNamedTypeNode()', () => {
+  test('gets wrapped type nodes', () => {
+    expect(getNamedTypeNode(wrapperTypeNode)).toEqual(wrappedTypeNode);
   });
 });
 
 describe('buildWrappedType()', () => {
-  it('should work', () => {
-    expect(buildWrappedType(GraphQLInt, wrappedTypeAST)).toEqual(wrappedType);
+  test('wraps types', () => {
+    expect(buildWrappedType(GraphQLInt, wrapperTypeNode)).toEqual(wrappedType);
   });
 });
 
 describe('produceType()', () => {
-  const customTypeAST = parse(`
+  const customTypeNode: any = parse(`
     scalar UUID
   `).definitions[0];
   const UUID = new GraphQLScalarType({ name: 'UUID', serialize: String });
 
-  it('should produce GraphQL scalars', () => {
-    const typeAST = parse(`
-      type Scalars {
+  test('produces GraphQL inner types', () => {
+    const typeNode: any = parse(`
+      type InnerTypes {
         int: Int
         float: Float
         string: String
         boolean: Boolean
         id: ID
+        schema: __Schema,
+        directive: __Directive,
+        directiveLocation: __DirectiveLocation,
+        type: __Type,
+        field: __Field,
+        inputValue: __InputValue,
+        enumValue: __EnumValue,
+        typeKind: __TypeKind,
       }
     `).definitions[0];
-    expect(typeAST.fields.map(({ type }) => type).map(produceType))
-      .toEqual([GraphQLInt, GraphQLFloat, GraphQLString, GraphQLBoolean, GraphQLID]);
+    expect(typeNode.fields.map(({ type }) => type).map(produceType)).toEqual([
+      GraphQLInt,
+      GraphQLFloat,
+      GraphQLString,
+      GraphQLBoolean,
+      GraphQLID,
+      __Schema,
+      __Directive,
+      __DirectiveLocation,
+      __Type,
+      __Field,
+      __InputValue,
+      __EnumValue,
+      __TypeKind,
+    ]);
   });
 
-  it('should produce GraphQL type wrappers', () => {
-    expect(produceType(wrappedTypeAST, [])).toEqual(wrappedType);
+  test('produces GraphQL type wrappers', () => {
+    expect(produceType(wrapperTypeNode, [])).toEqual(wrappedType);
   });
 
-  it('should produce custom types', () => {
-    expect(produceType(customTypeAST, [UUID])).toEqual(UUID);
+  test('produces custom types', () => {
+    expect(produceType(customTypeNode, [UUID])).toEqual(UUID);
   });
 
-  it('should throw if it can\'t produce the type', () => {
-    expect(() => produceType(customTypeAST, []))
+  test('throws if it can\'t produce the type', () => {
+    expect(() => produceType(customTypeNode, []))
       .toThrowError('Type "UUID" not found.');
   });
 });

src/build/produceType.js

@@ -1,48 +1,95 @@
+/* @flow */
+
 import {
+  type GraphQLType,
+  type GraphQLNamedType,
   GraphQLInt,
   GraphQLFloat,
   GraphQLString,
   GraphQLBoolean,
   GraphQLID,
   GraphQLList,
   GraphQLNonNull,
+  __Schema,
+  __Directive,
+  __DirectiveLocation,
+  __Type,
+  __Field,
+  __InputValue,
+  __EnumValue,
+  __TypeKind,
 } from 'graphql/type';
-import { Kind } from 'graphql/language';
-import resolveThunk from './resolveThunk';
+import { type TypeNode, type NamedTypeNode, Kind } from 'graphql/language';
+import invariant from './invariant';
+import resolveThunk, { type Thunk } from './resolveThunk';
 
 const { LIST_TYPE, NON_NULL_TYPE } = Kind;
 
-const scalarTypeMap = {
+/**
+ * Mirror of [innerTypeMap]{@link https://github.com/graphql/graphql-js/blob/master/src/utilities/buildASTSchema.js#L228}.
+ */
+const innerTypeMap = {
   Int: GraphQLInt,
   Float: GraphQLFloat,
   String: GraphQLString,
   Boolean: GraphQLBoolean,
   ID: GraphQLID,
+  __Schema,
+  __Directive,
+  __DirectiveLocation,
+  __Type,
+  __Field,
+  __InputValue,
+  __EnumValue,
+  __TypeKind,
 };
 
-export const getNamedTypeAST = (typeAST) => {
-  let namedTypeAST = typeAST;
-  while (namedTypeAST.kind === LIST_TYPE || namedTypeAST.kind === NON_NULL_TYPE) {
-    namedTypeAST = namedTypeAST.type;
+/**
+ * Retrieves the wrapped type AST given a wrapper type (GraphQLNonNull or GraphQLList) AST.
+ *
+ * Mirror of [getNamedTypeNode]{@link https://github.com/graphql/graphql-js/blob/master/src/utilities/buildASTSchema.js#L120}.
+ */
+export function getNamedTypeNode(typeNode: TypeNode): NamedTypeNode {
+  let namedType = typeNode;
+  while (namedType.kind === LIST_TYPE || namedType.kind === NON_NULL_TYPE) {
+    namedType = namedType.type;
   }
-  return namedTypeAST;
-};
+  return namedType;
+}
 
-export const buildWrappedType = (innerType, typeAST) => {
-  if (typeAST.kind === LIST_TYPE) {
-    return new GraphQLList(buildWrappedType(innerType, typeAST.type));
+/**
+ * Builds a GraphQL wrapper type (GraphQLNonNull or GraphQLList) given the type to wrap and the AST
+ * of the wrapper type.
+ *
+ * Mirror of [buildWrappedType]{@link https://github.com/graphql/graphql-js/blob/master/src/utilities/buildASTSchema.js#L105}.
+ */
+export function buildWrappedType(innerType: GraphQLType, inputTypeNode: TypeNode): GraphQLType {
+  if (inputTypeNode.kind === LIST_TYPE) {
+    return new GraphQLList(buildWrappedType(innerType, inputTypeNode.type));
   }
-  if (typeAST.kind === NON_NULL_TYPE) {
-    return new GraphQLNonNull(buildWrappedType(innerType, typeAST.type));
+  if (inputTypeNode.kind === NON_NULL_TYPE) {
+    const wrappedType = buildWrappedType(innerType, inputTypeNode.type);
+    invariant(!(wrappedType instanceof GraphQLNonNull), 'No nesting nonnull.');
+    return new GraphQLNonNull(wrappedType);
   }
   return innerType;
-};
+}
+
+/**
+ * Retrieves or builds a GraphQLType given the type AST and a thunk of GraphQLNamedType
+ * dependencies.
+ */
+export default function produceType(
+  typeNode: TypeNode,
+  typeDependencies: Thunk<Array<GraphQLNamedType>>,
+): GraphQLType {
+  const typeName = getNamedTypeNode(typeNode).name.value;
+
+  if (innerTypeMap[typeName]) return buildWrappedType(innerTypeMap[typeName], typeNode);
+
+  const type = resolveThunk(typeDependencies).find(({ name }) => name === typeName);
+
+  invariant(type, `Type "${typeName}" not found.`);
 
-export default function produceType(typeAST, types) {
-  const namedTypeAST = getNamedTypeAST(typeAST);
-  const typeName = namedTypeAST.name.value;
-  if (scalarTypeMap[typeName]) return buildWrappedType(scalarTypeMap[typeName], typeAST);
-  const maybeType = resolveThunk(types).find(({ name }) => name === typeName);
-  if (maybeType) return buildWrappedType(maybeType, typeAST);
-  throw new Error(`Type "${typeName}" not found.`);
+  return buildWrappedType(type, typeNode);
 }