feat(UnionTypeComposer): add getResolveType and setResolveType me…

…thods
graphql-compose · Feb 4, 2019 · 68bb865 · 68bb865
1 parent 426f4d4
commit 68bb865
Show file tree

Hide file tree

Showing 3 changed files with 68 additions and 1 deletion.
diff --git a/src/UnionTypeComposer.d.ts b/src/UnionTypeComposer.d.ts
@@ -111,6 +111,12 @@ export class UnionTypeComposer<TSource = any, TContext = any> {
   // ResolveType methods
   // -----------------------------------------------
 
+  public getResolveType(): GraphQLTypeResolver<any, TContext> | null | void;
+
+  public setResolveType(
+    fn: GraphQLTypeResolver<any, TContext> | null | void,
+  ): this;
+
   public hasTypeResolver(
     type: TypeComposer<any, TContext> | GraphQLObjectType,
   ): boolean;

diff --git a/src/UnionTypeComposer.js b/src/UnionTypeComposer.js
@@ -243,6 +243,15 @@ export class UnionTypeComposer<TContext> {
   // ResolveType methods
   // -----------------------------------------------
 
+  getResolveType(): ?GraphQLTypeResolver<any, TContext> {
+    return (this.gqType.resolveType: any);
+  }
+
+  setResolveType(fn: ?GraphQLTypeResolver<any, TContext>): UnionTypeComposer<TContext> {
+    this.gqType.resolveType = fn;
+    return this;
+  }
+
   hasTypeResolver(type: TypeComposer<TContext> | GraphQLObjectType): boolean {
     const typeResolversMap = this.getTypeResolvers();
     return typeResolversMap.has(type);
@@ -328,7 +337,7 @@ export class UnionTypeComposer<TContext> {
       };
     }
 
-    this.gqType.resolveType = resolveType;
+    this.setResolveType(resolveType);
     return this;
   }
 

diff --git a/src/__tests__/UnionTypeComposer-test.js b/src/__tests__/UnionTypeComposer-test.js
@@ -395,5 +395,57 @@ describe('UnionTypeComposer', () => {
       utc.removeTypeResolver(PersonTC);
       expect(utc.hasTypeResolver(PersonTC)).toBeFalsy();
     });
+
+    describe('check native resolveType methods', () => {
+      it('check methods setResolveType() getResolveType()', () => {
+        const utc1 = schemaComposer.createUnionTC(`union U = A | B`);
+        const resolveType = () => 'A';
+        expect(utc1.getResolveType()).toBeUndefined();
+        utc1.setResolveType(resolveType);
+        expect(utc1.getResolveType()).toBe(resolveType);
+      });
+
+      it('integration test', async () => {
+        const aTC = schemaComposer.createTC('type A { a: Int }');
+        const bTC = schemaComposer.createTC('type B { b: Int }');
+        const utc1 = schemaComposer.createUnionTC(`union U = A | B`);
+        const resolveType = value => {
+          if (value) {
+            if (value.a) return 'A';
+            else if (value.b) return 'B';
+          }
+          return null;
+        };
+
+        utc1.setResolveType(resolveType);
+        schemaComposer.addSchemaMustHaveType(aTC);
+        schemaComposer.addSchemaMustHaveType(bTC);
+        schemaComposer.Query.addFields({
+          check: {
+            type: '[U]',
+            resolve: () => [{ a: 1 }, { b: 2 }, { c: 3 }],
+          },
+        });
+        const res = await graphql(
+          schemaComposer.buildSchema(),
+          `
+            query {
+              check {
+                __typename
+                ... on A {
+                  a
+                }
+                ... on B {
+                  b
+                }
+              }
+            }
+          `
+        );
+        expect(res.data).toEqual({
+          check: [{ __typename: 'A', a: 1 }, { __typename: 'B', b: 2 }, null],
+        });
+      });
+    });
   });
 });