refactor: replace GraphQLInterfaceType by InterfaceTypeComposer

Author: nodkz

src/__tests__/composeWithMongooseDiscriminators-test.js

@@ -1,10 +1,12 @@
-import { GraphQLInterfaceType } from 'graphql';
+/* @flow */
+
 import {
   graphql,
   InputTypeComposer,
   SchemaComposer,
   schemaComposer,
   TypeComposer,
+  InterfaceTypeComposer,
 } from 'graphql-compose';
 import { getCharacterModels } from '../__mocks__/characterModels';
 import { MovieModel } from '../__mocks__/movieModel';
@@ -38,7 +40,7 @@ describe('composeWithMongooseDiscriminators ->', () => {
 
     it('should have an interface, accessed with getDInterface', () => {
       const cDTC = composeWithMongooseDiscriminators(CharacterModel);
-      expect(cDTC.getDInterface()).toBeInstanceOf(GraphQLInterfaceType);
+      expect(cDTC.getDInterface()).toBeInstanceOf(InterfaceTypeComposer);
     });
   });
 
@@ -196,8 +198,8 @@ describe('composeWithMongooseDiscriminators ->', () => {
         expect(
           characterDTC
             .getDInterface()
-            .getFields()
-            [fieldName].type.toString()
+            .getFieldType(fieldName)
+            .toString()
         ).toEqual(fieldExtension.type);
       });
 

src/discriminators/DiscriminatorTypeComposer.js

@@ -3,10 +3,10 @@
 import type { ComposeFieldConfigMap } from 'graphql-compose';
 import {
   EnumTypeComposer,
-  graphql,
   schemaComposer,
   SchemaComposer,
   TypeComposerClass,
+  type InterfaceTypeComposerClass,
 } from 'graphql-compose';
 import type { GraphQLFieldConfigMap } from 'graphql-compose/lib/graphql';
 import type {
@@ -22,8 +22,6 @@ import { mergeCustomizationOptions } from './merge-customization-options';
 import { prepareBaseResolvers } from './prepare-resolvers/prepareBaseResolvers';
 import { reorderFields } from './utils';
 
-const { GraphQLInterfaceType } = graphql;
-
 export type Options = {
   reorderFields?: boolean | string[], // true order: _id, DKey, DInterfaceFields, DiscriminatorFields
   customizationOptions?: TypeConverterOpts,
@@ -69,44 +67,14 @@ function createAndSetDKeyETC(dTC: DiscriminatorTypeComposer<any>, discriminators
   return DKeyETC;
 }
 
-function getBaseTCFieldsWithTypes(baseTC: TypeComposerClass<any>) {
-  const baseFields = baseTC.getFieldNames();
-  const baseFieldsWithTypes: GraphQLFieldConfigMap<any, any> = {};
-
-  for (const field of baseFields) {
-    baseFieldsWithTypes[field] = baseTC.getFieldConfig(field);
-  }
-
-  return baseFieldsWithTypes;
-}
-
-function createDInterface(baseModelTC: DiscriminatorTypeComposer<any>): GraphQLInterfaceType {
-  return new GraphQLInterfaceType({
-    name: `${baseModelTC.getTypeName()}Interface`,
-
-    resolveType: (value: any) => {
-      const childDName = value[baseModelTC.getDKey()];
-
-      if (childDName) {
-        return baseModelTC.schemaComposer.getTC(childDName).getType();
-      }
-
-      // as fallback return BaseModelTC
-      return baseModelTC.schemaComposer.getTC(baseModelTC.getTypeName()).getType();
-    },
-    // hoisting issue solved, get at time :)
-    fields: () => getBaseTCFieldsWithTypes(baseModelTC),
-  });
-}
-
 export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TContext> {
   discriminatorKey: string;
 
   DKeyETC: EnumTypeComposer;
 
   opts: Options;
 
-  DInterface: GraphQLInterfaceType;
+  DInterface: InterfaceTypeComposerClass<TContext>;
 
   childTCs: TypeComposerClass<TContext>[];
 
@@ -156,7 +124,7 @@ export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TCont
 
     reorderFields(baseDTC, (baseDTC.opts: any).reorderFields, baseDTC.discriminatorKey);
 
-    baseDTC.DInterface = createDInterface(baseDTC);
+    baseDTC.DInterface = baseDTC._createDInterface(baseDTC);
     baseDTC.setInterfaces([baseDTC.DInterface]);
 
     baseDTC.schemaComposer.addSchemaMustHaveType(baseDTC);
@@ -167,6 +135,31 @@ export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TCont
     return baseDTC;
   }
 
+  _createDInterface(baseTC: DiscriminatorTypeComposer<any>): InterfaceTypeComposerClass<TContext> {
+    return this.schemaComposer.InterfaceTypeComposer.create({
+      name: `${baseTC.getTypeName()}Interface`,
+
+      resolveType: (value: any) => {
+        const childDName = value[baseTC.getDKey()];
+
+        if (childDName) {
+          return baseTC.schemaComposer.getTC(childDName).getType();
+        }
+
+        // as fallback return BaseModelTC
+        return baseTC.schemaComposer.getTC(baseTC.getTypeName()).getType();
+      },
+      fields: (): ComposeFieldConfigMap<any, TContext> => {
+        const baseFields = baseTC.getFieldNames();
+        const interfaceFields = {};
+        for (const field of baseFields) {
+          interfaceFields[field] = baseTC.getFieldConfig(field);
+        }
+        return interfaceFields;
+      },
+    });
+  }
+
   getDKey(): string {
     return this.discriminatorKey;
   }

src/discriminators/prepare-resolvers/__tests__/recomposeBaseResolvers-test.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import { graphql } from 'graphql-compose';
 import { getCharacterModels } from '../../../__mocks__/characterModels';
 import { composeWithMongooseDiscriminators } from '../../../composeWithMongooseDiscriminators';
@@ -75,54 +77,58 @@ describe('recomposeBaseResolvers()', () => {
 
   it('should set resolver type to DInterface List, findMany', () => {
     expect(CharacterDTC.getResolver('findMany').getType()).toEqual(
-      graphql.GraphQLList(CharacterDTC.getDInterface())
+      graphql.GraphQLList(CharacterDTC.getDInterface().getType())
     );
   });
 
   it('should set resolver type to DInterface List, findByIds', () => {
     expect(CharacterDTC.getResolver('findByIds').getType()).toEqual(
-      graphql.GraphQLList(CharacterDTC.getDInterface())
+      graphql.GraphQLList(CharacterDTC.getDInterface().getType())
     );
   });
 
   it('should set resolver type to DInterface, findOne', () => {
-    expect(CharacterDTC.getResolver('findOne').getType()).toEqual(CharacterDTC.getDInterface());
+    expect(CharacterDTC.getResolver('findOne').getType()).toEqual(
+      CharacterDTC.getDInterface().getType()
+    );
   });
 
   it('should set resolver type to DInterface, findById', () => {
-    expect(CharacterDTC.getResolver('findById').getType()).toEqual(CharacterDTC.getDInterface());
+    expect(CharacterDTC.getResolver('findById').getType()).toEqual(
+      CharacterDTC.getDInterface().getType()
+    );
   });
 
   it('should set resolver record field type to DInterface, createOne', () => {
     expect(
       CharacterDTC.getResolver('createOne')
         .getTypeComposer()
         .getFieldType('record')
-    ).toEqual(CharacterDTC.getDInterface());
+    ).toEqual(CharacterDTC.getDInterface().getType());
   });
 
   it('should set resolver record field type to DInterface, updateOne', () => {
     expect(
       CharacterDTC.getResolver('updateOne')
         .getTypeComposer()
         .getFieldType('record')
-    ).toEqual(CharacterDTC.getDInterface());
+    ).toEqual(CharacterDTC.getDInterface().getType());
   });
 
   it('should set resolver record field type to DInterface, updateById', () => {
     expect(
       CharacterDTC.getResolver('updateById')
         .getTypeComposer()
         .getFieldType('record')
-    ).toEqual(CharacterDTC.getDInterface());
+    ).toEqual(CharacterDTC.getDInterface().getType());
   });
 
   it('should set resolver record field type to DInterface, ', () => {
     expect(
       CharacterDTC.getResolver('removeById')
         .getTypeComposer()
         .getFieldType('record')
-    ).toEqual(CharacterDTC.getDInterface());
+    ).toEqual(CharacterDTC.getDInterface().getType());
   });
 
   it('should set resolver record arg field, DKey to NonNull DKeyETC type, createOne', () => {
@@ -138,7 +144,7 @@ describe('recomposeBaseResolvers()', () => {
       CharacterDTC.getResolver('pagination')
         .getTypeComposer()
         .getFieldType('items')
-    ).toEqual(graphql.GraphQLList(CharacterDTC.getDInterface()));
+    ).toEqual(graphql.GraphQLList(CharacterDTC.getDInterface().getType()));
   });
 
   it('should clone, rename edges field on connection resolver, connection', () => {

src/discriminators/prepare-resolvers/prepareBaseResolvers.js

@@ -39,7 +39,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any>) {
       switch (resolverName) {
         case EMCResolvers.findMany:
         case EMCResolvers.findByIds:
-          resolver.setType(new GraphQLList(baseTC.getDInterface()));
+          resolver.setType(new GraphQLList(baseTC.getDInterface().getType()));
           break;
 
         case EMCResolvers.findById:
@@ -59,7 +59,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any>) {
 
         case EMCResolvers.pagination:
           resolver.getTypeComposer().extendField('items', {
-            type: new GraphQLList(baseTC.getDInterface()),
+            type: new GraphQLList(baseTC.getDInterface().getType()),
           });
           break;
 
@@ -70,7 +70,7 @@ export function prepareBaseResolvers(baseTC: DiscriminatorTypeComposer<any>) {
             .clone(`${baseTC.getTypeName()}Edge`);
 
           edgesTC.extendField('node', {
-            type: new GraphQLNonNull(baseTC.getDInterface()),
+            type: new GraphQLNonNull(baseTC.getDInterface().getType()),
           });
 
           resolver