fix(ConnectionType): For same GraphQLObject prepareConnectionType returns the same ConnectionType

Author: nodkz

src/__tests__/composeWithConnection-test.js

@@ -4,6 +4,7 @@ import { expect } from 'chai';
 import {
   graphql,
   GraphQLSchema,
+  GraphQLList,
 } from 'graphql';
 import { TypeComposer } from 'graphql-compose';
 import { composeWithConnection } from '../composeWithConnection';
@@ -51,9 +52,19 @@ describe('composeWithRelay', () => {
     });
   });
 
-  describe('TypeComposer props', () => {
-    it('should has `connection` resolver', () => {
-      expect(userComposer.getResolver('connection')).to.be.ok;
+  describe('check `connection` resolver props', () => {
+    const rsv = userComposer.getResolver('connection');
+    const type = rsv.getOutputType();
+    const tc = new TypeComposer(type);
+
+    it('should exists', () => {
+      expect(rsv).to.be.ok;
+    });
+
+    it('should has ConnectionType as outputType', () => {
+      expect(type).to.be.ok;
+      expect(tc.getFieldNames()).to.have.members(['count', 'pageInfo', 'edges']);
+      expect(tc.getFieldType('edges')).instanceof(GraphQLList);
     });
   });
 

src/types/__tests__/connectionType-test.js

@@ -42,6 +42,12 @@ describe('types/connectionType.js', () => {
       const edgeType = prepareEdgeType(userTypeComposer);
       expect(edgeType).property('ofType').equals(userTypeComposer.getType());
     });
+
+    it('should return same type for same Type in TypeComposer', () => {
+      const t1 = prepareEdgeType(userTypeComposer);
+      const t2 = prepareEdgeType(userTypeComposer);
+      expect(t1).equals(t2);
+    });
   });
 
   describe('prepareConnectionType()', () => {
@@ -82,5 +88,11 @@ describe('types/connectionType.js', () => {
       const connectionType = prepareConnectionType(userTypeComposer);
       expect(connectionType).property('ofType').equals(userTypeComposer.getType());
     });
+
+    it('should return same type for same Type in TypeComposer', () => {
+      const t1 = prepareConnectionType(userTypeComposer);
+      const t2 = prepareConnectionType(userTypeComposer);
+      expect(t1).equals(t2);
+    });
   });
 });

src/types/connectionType.js

@@ -14,9 +14,16 @@ import GraphQLConnectionCursor from './cursorType';
 
 import PageInfoType from './pageInfoType';
 
+const cachedConnectionTypes = new WeakMap;
+const cachedEdgeTypes = new WeakMap;
 
 export function prepareEdgeType(typeComposer: TypeComposer): GraphQLObjectType {
   const name = `${typeComposer.getTypeName()}Edge`;
+  const type = typeComposer.getType();
+
+  if (cachedEdgeTypes.has(type)) {
+    return cachedEdgeTypes.get(type);
+  }
 
   const edgeType = new GraphQLObjectType({
     name,
@@ -32,13 +39,20 @@ export function prepareEdgeType(typeComposer: TypeComposer): GraphQLObjectType {
       },
     }),
   });
-  edgeType.ofType = typeComposer.getType();
+  edgeType.ofType = type;
+
+  cachedEdgeTypes.set(type, edgeType);
   return edgeType;
 }
 
 
 export function prepareConnectionType(typeComposer: TypeComposer): GraphQLObjectType {
   const name = `${typeComposer.getTypeName()}Connection`;
+  const type = typeComposer.getType();
+
+  if (cachedConnectionTypes.has(type)) {
+    return cachedConnectionTypes.get(type);
+  }
 
   const connectionType = new GraphQLObjectType({
     name,
@@ -58,6 +72,8 @@ export function prepareConnectionType(typeComposer: TypeComposer): GraphQLObject
       },
     }),
   });
-  connectionType.ofType = typeComposer.getType();
+  connectionType.ofType = type;
+
+  cachedConnectionTypes.set(type, connectionType);
   return connectionType;
 }