fix: properly construct Union types from ComposeConfig

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

Hide file tree

Showing 5 changed files with 59 additions and 7 deletions.
diff --git a/src/UnionTypeComposer.js b/src/UnionTypeComposer.js
@@ -151,7 +151,7 @@ export class UnionTypeComposer<TSource, TContext> {
       const types = this.gqType.getTypes();
       const m: Map<string, ComposeObjectType> = new Map();
       types.forEach(type => {
-        m.set(type.name, type);
+        m.set(getComposeTypeName(type), type);
       });
       this.gqType._gqcTypeMap = m;
 

diff --git a/src/__tests__/InputTypeComposer-test.js b/src/__tests__/InputTypeComposer-test.js
@@ -380,6 +380,23 @@ describe('InputTypeComposer', () => {
       expect((itc1.getFieldType('f2'): any).ofType).toBe(GraphQLInt);
     });
 
+    it('should create ITC by ComposeObjectTypeConfig with unexisted types', () => {
+      const itc1 = schemaComposer.createInputTC({
+        name: 'TestTypeInput',
+        fields: {
+          f1: {
+            type: 'Type1',
+          },
+          f2: 'Type2!',
+        },
+      });
+      expect(itc1).toBeInstanceOf(InputTypeComposer);
+      expect(itc1.getField('f1')).toEqual({
+        type: 'Type1',
+      });
+      expect(itc1.getField('f2')).toEqual('Type2!');
+    });
+
     it('should create ITC by GraphQLObjectTypeConfig with fields as Thunk', () => {
       const itc1 = schemaComposer.createInputTC({
         name: 'TestTypeInput',

diff --git a/src/__tests__/InterfaceTypeComposer-test.js b/src/__tests__/InterfaceTypeComposer-test.js
@@ -363,6 +363,23 @@ describe('InterfaceTypeComposer', () => {
       expect((myIFTC.getFieldType('f2'): any).ofType).toBe(GraphQLInt);
     });
 
+    it('should create TC by ComposeInterfaceTypeConfig with unexisted types', () => {
+      const myIFTC = schemaComposer.createInterfaceTC({
+        name: 'TestType',
+        fields: {
+          f1: {
+            type: 'Type1',
+          },
+          f2: 'Type2!',
+        },
+      });
+      expect(myIFTC).toBeInstanceOf(InterfaceTypeComposer);
+      expect(myIFTC.getField('f1')).toEqual({
+        type: 'Type1',
+      });
+      expect(myIFTC.getField('f2')).toEqual('Type2!');
+    });
+
     it('should create TC by GraphQLInterfaceTypeConfig with fields as Thunk', () => {
       const myIFTC = schemaComposer.createInterfaceTC({
         name: 'TestType',

diff --git a/src/__tests__/ObjectTypeComposer-test.js b/src/__tests__/ObjectTypeComposer-test.js
@@ -448,7 +448,7 @@ describe('ObjectTypeComposer', () => {
       expect(myTC.getFields()).toEqual({});
     });
 
-    it('should create TC by type template string', () => {
+    it('should create TC by SDL', () => {
       const myTC = ObjectTypeComposer.create(
         `
         type TestTypeTpl {
@@ -485,6 +485,24 @@ describe('ObjectTypeComposer', () => {
       expect((myTC.getFieldType('f2'): any).ofType).toBe(GraphQLInt);
     });
 
+    it('should create TC by ComposeObjectTypeConfig with unexisted types', () => {
+      const myTC = ObjectTypeComposer.create(
+        {
+          name: 'TestType',
+          fields: {
+            f1: {
+              type: 'Type1',
+            },
+            f2: 'Type2!',
+          },
+        },
+        schemaComposer
+      );
+      expect(myTC).toBeInstanceOf(ObjectTypeComposer);
+      expect(myTC.getField('f1')).toEqual({ type: 'Type1' });
+      expect(myTC.getField('f2')).toEqual('Type2!');
+    });
+
     it('should create TC by GraphQLObjectTypeConfig with fields as Thunk', () => {
       const myTC = ObjectTypeComposer.create(
         {

diff --git a/src/__tests__/UnionTypeComposer-test.js b/src/__tests__/UnionTypeComposer-test.js
@@ -61,20 +61,20 @@ describe('UnionTypeComposer', () => {
       expect(types[1]).toBeInstanceOf(GraphQLObjectType);
     });
 
-    it('should create UTC by UnionTypeConfig', () => {
+    it('should create UTC by UnionTypeConfig with unexisted types', () => {
       const myUTC = UnionTypeComposer.create(
         {
           name: 'TestType',
-          types: () => [`type AA { a: Int }`, `BB`],
+          types: [`type AA { a: Int }`, `BB`],
         },
         sc
       );
       expect(myUTC).toBeInstanceOf(UnionTypeComposer);
-      ObjectTypeComposer.create(`type BB { b: Int }`, sc);
+      expect(myUTC.getTypeNames()).toEqual(['AA', 'BB']);
       const types = myUTC.getTypes();
       expect(types).toHaveLength(2);
-      expect(types[0]).toBeInstanceOf(GraphQLObjectType);
-      expect(types[1]).toBeInstanceOf(GraphQLObjectType);
+      expect(types[0]).toBe(`type AA { a: Int }`);
+      expect(types[1]).toBe(`BB`);
     });
 
     it('should create UTC by GraphQLUnionType', () => {