fix: make AST parsing use composers (#183)

graphql-compose · Apr 4, 2019 · ae9e9dc · ae9e9dc
1 parent f4f0bc2
commit ae9e9dc
Show file tree

Hide file tree

Showing 11 changed files with 297 additions and 242 deletions.
diff --git a/src/EnumTypeComposer.js b/src/EnumTypeComposer.js
@@ -67,14 +67,13 @@ export class EnumTypeComposer<TContext> {
           sc
         );
       } else {
-        const type = sc.typeMapper.createType(typeName);
-        if (!(type instanceof GraphQLEnumType)) {
+        ETC = sc.typeMapper.createType(typeName);
+        if (!(ETC instanceof EnumTypeComposer)) {
           throw new Error(
             'You should provide correct GraphQLEnumType type definition.' +
               'Eg. `enum MyType { KEY1 KEY2 KEY3 }`'
           );
         }
-        ETC = new EnumTypeComposer(type, sc);
       }
     } else if (typeDef instanceof GraphQLEnumType) {
       ETC = new EnumTypeComposer(typeDef, sc);

diff --git a/src/InputTypeComposer.js b/src/InputTypeComposer.js
@@ -115,14 +115,13 @@ export class InputTypeComposer<TContext> {
           sc
         );
       } else {
-        const type = sc.typeMapper.createType(typeName);
-        if (!(type instanceof GraphQLInputObjectType)) {
+        ITC = sc.typeMapper.createType(typeName);
+        if (!(ITC instanceof InputTypeComposer)) {
           throw new Error(
             'You should provide correct GraphQLInputObjectType type definition.' +
               'Eg. `input MyInputType { name: String! }`'
           );
         }
-        ITC = new InputTypeComposer(type, sc);
       }
     } else if (typeDef instanceof GraphQLInputObjectType) {
       ITC = new InputTypeComposer(typeDef, sc);

diff --git a/src/InterfaceTypeComposer.js b/src/InterfaceTypeComposer.js
@@ -112,14 +112,13 @@ export class InterfaceTypeComposer<TSource, TContext> {
           sc
         );
       } else {
-        const type = sc.typeMapper.createType(typeName);
-        if (!(type instanceof GraphQLInterfaceType)) {
+        IFTC = sc.typeMapper.createType(typeName);
+        if (!(IFTC instanceof InterfaceTypeComposer)) {
           throw new Error(
             'You should provide correct GraphQLInterfaceType type definition.' +
               'Eg. `interface MyType { id: ID!, name: String! }`'
           );
         }
-        IFTC = new InterfaceTypeComposer(type, sc);
       }
     } else if (typeDef instanceof GraphQLInterfaceType) {
       IFTC = new InterfaceTypeComposer(typeDef, sc);

diff --git a/src/ObjectTypeComposer.js b/src/ObjectTypeComposer.js
@@ -242,14 +242,13 @@ export class ObjectTypeComposer<TSource, TContext> {
           sc
         );
       } else {
-        const type = sc.typeMapper.createType(typeName);
-        if (!(type instanceof GraphQLObjectType)) {
+        TC = sc.typeMapper.createType(typeName);
+        if (!(TC instanceof ObjectTypeComposer)) {
           throw new Error(
             'You should provide correct GraphQLObjectType type definition.' +
               'Eg. `type MyType { name: String }`'
           );
         }
-        TC = new ObjectTypeComposer(type, sc);
       }
     } else if (typeDef instanceof GraphQLObjectType) {
       TC = new ObjectTypeComposer(typeDef, sc);

diff --git a/src/ScalarTypeComposer.js b/src/ScalarTypeComposer.js
@@ -65,13 +65,12 @@ export class ScalarTypeComposer<TContext> {
           sc
         );
       } else {
-        const type = sc.typeMapper.createType(typeName);
-        if (!(type instanceof GraphQLScalarType)) {
+        STC = sc.typeMapper.createType(typeName);
+        if (!(STC instanceof ScalarTypeComposer)) {
           throw new Error(
             'You should provide correct GraphQLScalarType type definition. Eg. `scalar UInt`'
           );
         }
-        STC = new ScalarTypeComposer(type, sc);
       }
     } else if (typeDef instanceof GraphQLScalarType) {
       STC = new ScalarTypeComposer(typeDef, sc);

diff --git a/src/SchemaComposer.js b/src/SchemaComposer.js
@@ -40,7 +40,15 @@ type ExtraSchemaConfig = {
   astNode?: SchemaDefinitionNode | null,
 };
 
-type AnyType<TContext> =
+export type AnyComposeType<TContext> =
+  | ObjectTypeComposer<any, TContext>
+  | InputTypeComposer<TContext>
+  | EnumTypeComposer<TContext>
+  | InterfaceTypeComposer<any, TContext>
+  | UnionTypeComposer<any, TContext>
+  | ScalarTypeComposer<TContext>;
+
+export type AnyType<TContext> =
   | ObjectTypeComposer<any, TContext>
   | InputTypeComposer<TContext>
   | EnumTypeComposer<TContext>
@@ -193,34 +201,46 @@ export class SchemaComposer<TContext> extends TypeStorage<any, any> {
    * -----------------------------------------------
    */
 
-  addTypeDefs(typeDefs: string): TypeStorage<string, GraphQLNamedType> {
+  addTypeDefs(typeDefs: string): TypeStorage<string, AnyComposeType<any>> {
     const types = this.typeMapper.parseTypesFromString(typeDefs);
-    types.forEach((type: any) => {
-      const name = type.name;
+    types.forEach((type: AnyComposeType<any>) => {
+      const name = type.getTypeName();
       if (name !== 'Query' && name !== 'Mutation' && name !== 'Subscription') {
-        this.add((type: any));
+        this.add(type);
       }
     });
     if (types.has('Query')) {
-      this.Query.addFields(ObjectTypeComposer.create((types.get('Query'): any), this).getFields());
+      const tc = types.get('Query');
+      if (!(tc instanceof ObjectTypeComposer)) {
+        throw new Error(`Type Query in typedefs isn't an Object Type.`);
+      }
+      this.Query.addFields(tc.getFields());
     }
     if (types.has('Mutation')) {
-      this.Mutation.addFields(
-        ObjectTypeComposer.create((types.get('Mutation'): any), this).getFields()
-      );
+      const tc = types.get('Mutation');
+      if (!(tc instanceof ObjectTypeComposer)) {
+        throw new Error(`Type Mutation in typedefs isn't an Object Type.`);
+      }
+      this.Mutation.addFields(tc.getFields());
     }
     if (types.has('Subscription')) {
-      this.Subscription.addFields(
-        ObjectTypeComposer.create((types.get('Subscription'): any), this).getFields()
-      );
+      const tc = types.get('Subscription');
+      if (!(tc instanceof ObjectTypeComposer)) {
+        throw new Error(`Type Subscription in typedefs isn't an Object Type.`);
+      }
+      this.Subscription.addFields(tc.getFields());
     }
     return types;
   }
 
   addResolveMethods(typesFieldsResolve: GraphQLToolsResolveMethods<TContext>): void {
     const typeNames = Object.keys(typesFieldsResolve);
     typeNames.forEach(typeName => {
-      if (this.get(typeName) instanceof GraphQLScalarType) {
+      let type = this.get(typeName);
+      if (type instanceof ScalarTypeComposer) {
+        type = type.getType();
+      }
+      if (type instanceof GraphQLScalarType) {
         const maybeScalar: any = typesFieldsResolve[typeName];
         if (maybeScalar instanceof GraphQLScalarType) {
           this.set(typeName, maybeScalar);
@@ -500,7 +520,9 @@ export class SchemaComposer<TContext> extends TypeStorage<any, any> {
     | UnionTypeComposer<any, TContext>
     | ScalarTypeComposer<TContext> {
     const type = this.get(typeName);
-    if (
+    if (type == null) {
+      throw new Error(`Cannot find type with name ${typeName}`);
+    } else if (
       type instanceof ObjectTypeComposer ||
       type instanceof InputTypeComposer ||
       type instanceof ScalarTypeComposer ||