feat(TypeMapper): now lookup type as string in the GQC

Author: nodkz

src/__tests__/typeMapper-test.js

@@ -16,6 +16,11 @@ import typeMapper from '../typeMapper';
 import TypeComposer from '../typeComposer';
 import InputTypeComposer from '../inputTypeComposer';
 import Resolver from '../resolver';
+import GQC from '../gqc';
+
+beforeEach(() => {
+  GQC.clear();
+});
 
 describe('TypeMapper', () => {
   it('should have basic mapper functions', () => {
@@ -152,6 +157,14 @@ describe('TypeMapper', () => {
         expect(fc.type).toBe(GraphQLString);
       });
 
+      it('should lookup type name as string in GQC', () => {
+        const tc = TypeComposer.create(`type MyType { a: Int }`);
+        GQC.add(tc);
+
+        const fc = typeMapper.convertOutputFieldConfig('MyType');
+        expect(fc.type).toBe(tc.getType());
+      });
+
       it('should create field config from GraphQL Schema Language', () => {
         const fc = typeMapper.convertOutputFieldConfig(
           `type MyOutputType {
@@ -360,6 +373,14 @@ describe('TypeMapper', () => {
       expect(ic.type).toBe(GraphQLString);
     });
 
+    it('should lookup type name as string in GQC', () => {
+      const itc = InputTypeComposer.create(`input MyInput { a: Int }`);
+      GQC.add(itc);
+
+      const ic = typeMapper.convertInputFieldConfig('MyInput');
+      expect(ic.type).toBe(itc.getType());
+    });
+
     it('should create field config from input type GraphQL Schema Language', () => {
       const fc: any = typeMapper.convertInputFieldConfig(
         `input MyInputType {
@@ -527,6 +548,14 @@ describe('TypeMapper', () => {
       expect(ac.type).toBe(GraphQLString);
     });
 
+    it('should lookup type name as string in GQC', () => {
+      const itc = InputTypeComposer.create(`input MyArg { a: Int }`);
+      GQC.add(itc);
+
+      const ac = typeMapper.convertArgConfig('MyArg');
+      expect(ac.type).toBe(itc.getType());
+    });
+
     it('should create arg config from input type GraphQL Schema Language', () => {
       const fc: any = typeMapper.convertArgConfig(
         `input MyInputArg {

src/typeMapper.js

@@ -87,6 +87,7 @@ import type { Thunk } from './utils/definitions';
 import TypeComposer from './typeComposer';
 import InputTypeComposer from './inputTypeComposer';
 import Resolver from './resolver';
+import GQC from './gqc';
 
 export type TypeDefinitionString = string; // eg type Name { field: Int }
 export type TypeWrappedString = string; // eg. Int, Int!, [Int]
@@ -247,19 +248,23 @@ class TypeMapper {
         );
       }
 
-      const type =
-        RegexpOutputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
-          ? this.createType(composeType)
-          : this.getWrapped(composeType);
-
-      if (!type) {
-        throw new Error(
-          `${typeName}.${fieldName} cannot convert to OutputType the following string: '${
-            composeType
-          }'`
-        );
+      if (GQC.hasInstance(composeType, TypeComposer)) {
+        fieldConfig.type = GQC.getTC(composeType).getType();
+      } else {
+        const type =
+          RegexpOutputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
+            ? this.createType(composeType)
+            : this.getWrapped(composeType);
+
+        if (!type) {
+          throw new Error(
+            `${typeName}.${fieldName} cannot convert to OutputType the following string: '${
+              composeType
+            }'`
+          );
+        }
+        fieldConfig.type = (type: any);
       }
-      fieldConfig.type = (type: any);
     } else if (composeType instanceof TypeComposer) {
       fieldConfig.type = composeType.getType();
     } else if (composeType instanceof Resolver) {
@@ -378,20 +383,24 @@ class TypeMapper {
         );
       }
 
-      const type =
-        RegexpInputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
-          ? this.createType(composeType)
-          : this.getWrapped(composeType);
+      if (GQC.hasInstance(composeType, InputTypeComposer)) {
+        argConfig.type = GQC.getITC(composeType).getType();
+      } else {
+        const type =
+          RegexpInputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
+            ? this.createType(composeType)
+            : this.getWrapped(composeType);
+
+        if (!type) {
+          throw new Error(
+            `${typeName}.${fieldName}@${
+              argName
+            } cannot convert to InputType the following string: '${composeType}'`
+          );
+        }
 
-      if (!type) {
-        throw new Error(
-          `${typeName}.${fieldName}@${argName} cannot convert to InputType the following string: '${
-            composeType
-          }'`
-        );
+        argConfig.type = (type: any);
       }
-
-      argConfig.type = (type: any);
     } else if (composeType instanceof InputTypeComposer) {
       argConfig.type = composeType.getType();
     } else {
@@ -506,20 +515,24 @@ class TypeMapper {
         );
       }
 
-      const type =
-        RegexpInputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
-          ? this.createType(composeType)
-          : this.getWrapped(composeType);
+      if (GQC.hasInstance(composeType, InputTypeComposer)) {
+        fieldConfig.type = GQC.getITC(composeType).getType();
+      } else {
+        const type =
+          RegexpInputTypeDefinition.test(composeType) || RegexpEnumTypeDefinition.test(composeType)
+            ? this.createType(composeType)
+            : this.getWrapped(composeType);
+
+        if (!type) {
+          throw new Error(
+            `${typeName}.${fieldName} cannot convert to InputType the following string: '${
+              composeType
+            }'`
+          );
+        }
 
-      if (!type) {
-        throw new Error(
-          `${typeName}.${fieldName} cannot convert to InputType the following string: '${
-            composeType
-          }'`
-        );
+        fieldConfig.type = (type: any);
       }
-
-      fieldConfig.type = (type: any);
     } else if (composeType instanceof InputTypeComposer) {
       fieldConfig.type = composeType.getType();
     } else {