should handle extend types when GraphQLSchema is the source

packages/epoxy/src/schema-mergers/merge-schema.ts

@@ -1,15 +1,29 @@
-import { buildASTSchema, printSchema, DefinitionNode, DocumentNode, GraphQLSchema, parse, print, Source, GraphQLObjectType, isSpecifiedScalarType, isIntrospectionType, GraphQLScalarType, printType } from 'graphql';
+import {
+  buildASTSchema,
+  printSchema,
+  DefinitionNode,
+  DocumentNode,
+  GraphQLSchema,
+  parse,
+  print,
+  Source,
+  GraphQLObjectType,
+  isSpecifiedScalarType,
+  isIntrospectionType,
+  GraphQLScalarType,
+  printType,
+  ObjectTypeExtensionNode,
+  GraphQLNamedType,
+  isObjectType,
+} from 'graphql';
 import { isGraphQLSchema, isSourceTypes, isStringTypes, isSchemaDefinition } from './utils';
 import { MergedResultMap, mergeGraphQLNodes } from './merge-nodes';
 
 interface Config {
   useSchemaDefinition?: boolean;
 }
 
-export function mergeGraphQLSchemas(
-  types: Array<string | Source | DocumentNode | GraphQLSchema>,
-  config?: Partial<Config>,
-): DocumentNode {
+export function mergeGraphQLSchemas(types: Array<string | Source | DocumentNode | GraphQLSchema>, config?: Partial<Config>): DocumentNode {
   return {
     kind: 'Document',
     definitions: mergeGraphQLTypes(types, {
@@ -29,9 +43,9 @@ function createSchemaDefinition(def: {
   subscription: string | GraphQLObjectType | null;
 }): string {
   const schemaRoot: {
-    query?: string,
-    mutation?: string,
-    subscription?: string,
+    query?: string;
+    mutation?: string;
+    subscription?: string;
   } = {};
 
   if (def.query) {
@@ -55,10 +69,7 @@ function createSchemaDefinition(def: {
   return undefined;
 }
 
-export function mergeGraphQLTypes(
-  types: Array<string | Source | DocumentNode | GraphQLSchema>,
-  config: Config,
-): DefinitionNode[] {
+export function mergeGraphQLTypes(types: Array<string | Source | DocumentNode | GraphQLSchema>, config: Config): DefinitionNode[] {
   const allNodes: ReadonlyArray<DefinitionNode> = types
     .map<DocumentNode>(type => {
       if (isGraphQLSchema(type)) {
@@ -84,7 +95,13 @@ export function mergeGraphQLTypes(
 
             return !isPredefinedScalar && !isIntrospection;
           })
-          .map(type => (type.astNode ? print(type.astNode) : printType(type)))
+          .map(type => {
+            if (type.astNode) {
+              return print(type.extensionASTNodes ? extendDefinition(type) : type.astNode);
+            } else {
+              return printType(type);
+            }
+          })
           .filter(e => e);
         const directivesDeclaration = schema
           .getDirectives()
@@ -145,3 +162,18 @@ export function mergeGraphQLTypes(
 
   return [...Object.values(mergedNodes), parse(schemaDefinition).definitions[0]];
 }
+
+function extendDefinition(type: GraphQLNamedType): GraphQLNamedType['astNode'] {
+  switch (type.astNode.kind) {
+    case 'ObjectTypeDefinition':
+      return {
+        ...type.astNode,
+        // add fields from object extension (`extend type Query { newField: String }`)
+        fields: type.astNode.fields.concat(
+          (type.extensionASTNodes as ReadonlyArray<ObjectTypeExtensionNode>).reduce((fields, node) => fields.concat(node.fields), []),
+        ),
+      };
+    default:
+      return type.astNode;
+  }
+}

packages/epoxy/tests/merge-schema.spec.ts

@@ -584,6 +584,79 @@ describe('Merge Schema', () => {
         }
       `));
     });
+    it('should handle extend types when GraphQLSchema is the source', () => {
+      const schema = makeExecutableSchema({
+        typeDefs: [`
+          type Query {
+            foo: String
+          }
+
+          type User {
+            name: String
+          }
+        `, `
+          extend type Query {
+            bar: String
+          }
+
+          extend type User {
+            id: ID
+          }
+        `],
+      });
+      const merged = mergeGraphQLSchemas([schema]);
+      const printed = stripWhitespaces(print(merged));
+
+      expect(printed).toContain(stripWhitespaces(`
+        type Query {
+          foo: String
+          bar: String
+        }
+      `));
+      expect(printed).toContain(stripWhitespaces(`
+        type User {
+          name: String
+          id: ID
+        }
+      `));
+    });
+
+    it('should fail when a field is already defined and has a different type', () => {
+      expect(() => {
+        mergeGraphQLSchemas([`
+          type Query {
+            foo: String
+          }
+        `, `
+          extend type Query {
+            foo: Int
+            bar: String
+          }
+        `]);
+      }).toThrowError('Unable to merge GraphQL type');
+    });
+
+    it('should preserve an extend keyword if there is no base', () => {
+      const merged = mergeGraphQLSchemas([`
+        extend type Query {
+          foo: String
+        }
+      `, `
+        extend type Query {
+          bar: String
+        }
+      `]);
+
+      const printed = stripWhitespaces(print(merged));
+
+      expect(printed).toContain(stripWhitespaces(`
+        extend type Query {
+          foo: String
+          bar: String
+        }
+      `));
+    });
+
     it('should handle extend inputs', () => {
       const merged = mergeGraphQLSchemas([`
         input TestInput {