Merge pull request #252 from nerdmed/master

use function reference instead of string for concatenateTypeDefs

src/schemaGenerator.ts

@@ -110,16 +110,17 @@ function makeExecutableSchema({
   return jsSchema;
 }
 
-function concatenateTypeDefs(typeDefinitionsAry: ITypedef[], functionsCalled = {}): string {
+function concatenateTypeDefs(typeDefinitionsAry: ITypedef[], calledFunctionRefs = [] as any ): string {
   let resolvedTypeDefinitions: string[] = [];
   typeDefinitionsAry.forEach((typeDef: ITypedef) => {
     if (typeof typeDef === 'function') {
-      if (!(typeDef as any in functionsCalled)) {
-        functionsCalled[typeDef as any] = 1;
+      if (calledFunctionRefs.indexOf(typeDef) === -1) {
+        calledFunctionRefs.push(typeDef);
         resolvedTypeDefinitions = resolvedTypeDefinitions.concat(
-          concatenateTypeDefs(typeDef(), functionsCalled)
+          concatenateTypeDefs(typeDef(), calledFunctionRefs)
         );
       }
+
     } else if (typeof typeDef === 'string') {
       resolvedTypeDefinitions.push(typeDef.trim());
     } else {
@@ -516,4 +517,5 @@ export {
   buildSchemaFromTypeDefinitions,
   addSchemaLevelResolveFunction,
   attachConnectorsToContext,
+  concatenateTypeDefs,
 };

src/test/testSchemaGenerator.ts

@@ -24,6 +24,7 @@ import {
   attachConnectorsToContext,
   assertResolveFunctionsPresent,
   chainResolvers,
+  concatenateTypeDefs,
 } from '../schemaGenerator';
 import { IResolverValidationOptions, IResolvers } from '../Interfaces';
 import 'mocha';
@@ -286,6 +287,30 @@ describe('generating schema from shorthand', () => {
     expect(jsSchema.getQueryType().getFields()).to.have.all.keys('foo', 'bar');
   });
 
+  it('can concatenateTypeDefs created by a function inside a closure', () => {
+    const typeA = { typeDefs: () => ['type TypeA { foo: String }'] };
+    const typeB = { typeDefs: () => ['type TypeB { bar: String }'] };
+    const typeC = { typeDefs: () => ['type TypeC { foo: String }'] };
+    const typeD = { typeDefs: () => ['type TypeD { bar: String }'] };
+
+    function combineTypeDefs(...args: Array<any>): any {
+      return { typeDefs: () => args.map(o => o.typeDefs) };
+    }
+
+    const combinedAandB = combineTypeDefs(typeA, typeB);
+    const combinedCandD = combineTypeDefs(typeC, typeD);
+
+    const result = concatenateTypeDefs([
+      combinedAandB.typeDefs,
+      combinedCandD.typeDefs
+    ]);
+
+    expect(result).to.contain('type TypeA');
+    expect(result).to.contain('type TypeB');
+    expect(result).to.contain('type TypeC');
+    expect(result).to.contain('type TypeD');
+  });
+
   it('properly deduplicates the array of type DefinitionNodes', () => {
     const typeDefAry = [`
       type Query {