feat(InterfaceTypeComposer): add getResolveType and `setResolveType…

…` methods
graphql-compose · Feb 4, 2019 · 426f4d4 · 426f4d4
1 parent be7c4c0
commit 426f4d4
Show file tree

Hide file tree

Showing 3 changed files with 69 additions and 1 deletion.
diff --git a/src/InterfaceTypeComposer.d.ts b/src/InterfaceTypeComposer.d.ts
@@ -170,6 +170,12 @@ export class InterfaceTypeComposer<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/InterfaceTypeComposer.js b/src/InterfaceTypeComposer.js
@@ -486,6 +486,15 @@ export class InterfaceTypeComposer<TContext> {
   // ResolveType methods
   // -----------------------------------------------
 
+  getResolveType(): ?GraphQLTypeResolver<any, TContext> {
+    return (this.gqType.resolveType: any);
+  }
+
+  setResolveType(fn: ?GraphQLTypeResolver<any, TContext>): InterfaceTypeComposer<TContext> {
+    this.gqType.resolveType = fn;
+    return this;
+  }
+
   hasTypeResolver(type: TypeComposer<TContext> | GraphQLObjectType): boolean {
     const typeResolversMap = this.getTypeResolvers();
     return typeResolversMap.has(type);
@@ -570,7 +579,7 @@ export class InterfaceTypeComposer<TContext> {
       };
     }
 
-    this.gqType.resolveType = resolveType;
+    this.setResolveType(resolveType);
     return this;
   }
 

diff --git a/src/__tests__/InterfaceTypeComposer-test.js b/src/__tests__/InterfaceTypeComposer-test.js
@@ -8,6 +8,7 @@ import {
   GraphQLFloat,
   GraphQLBoolean,
   GraphQLInterfaceType,
+  graphql,
 } from '../graphql';
 import { InterfaceTypeComposer, schemaComposer, TypeComposer } from '..';
 import { graphqlVersion } from '../utils/graphqlVersion';
@@ -631,5 +632,57 @@ describe('InterfaceTypeComposer', () => {
       iftc.removeTypeResolver(PersonTC);
       expect(iftc.hasTypeResolver(PersonTC)).toBeFalsy();
     });
+
+    describe('check native resolveType methods', () => {
+      it('check methods setResolveType() getResolveType()', () => {
+        const iftc1 = schemaComposer.createInterfaceTC(`interface F { f: Int }`);
+        const resolveType = () => 'A';
+        expect(iftc1.getResolveType()).toBeUndefined();
+        iftc1.setResolveType(resolveType);
+        expect(iftc1.getResolveType()).toBe(resolveType);
+      });
+
+      it('integration test', async () => {
+        const iftc1 = schemaComposer.createInterfaceTC(`interface F { f: Int }`);
+        const aTC = schemaComposer.createTC('type A implements F { a: Int, f: Int }');
+        const bTC = schemaComposer.createTC('type B implements F { b: Int, f: Int }');
+        const resolveType = value => {
+          if (value) {
+            if (value.a) return 'A';
+            else if (value.b) return 'B';
+          }
+          return null;
+        };
+
+        iftc1.setResolveType(resolveType);
+        schemaComposer.addSchemaMustHaveType(aTC);
+        schemaComposer.addSchemaMustHaveType(bTC);
+        schemaComposer.Query.addFields({
+          check: {
+            type: '[F]',
+            resolve: () => [{ f: 'A', a: 1 }, { f: 'B', b: 2 }, { f: 'C', 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],
+        });
+      });
+    });
   });
 });