Fix the arguments of GraphQL enum types resolves to merged schema

.gitignore

@@ -5,3 +5,4 @@ dist
 *.tgz
 .DS_Store
 package-lock.json
+.idea

src/stitching/delegateToSchema.ts

@@ -184,12 +184,10 @@ export function createDocument(
     selectionSet,
   };
 
-  const newDoc: DocumentNode = {
+  return {
     kind: Kind.DOCUMENT,
     definitions: [operationDefinition, ...processedFragments],
   };
-
-  return newDoc;
 }
 
 function processRootField(

src/stitching/makeRemoteExecutableSchema.ts

@@ -14,6 +14,7 @@ import {
   GraphQLBoolean,
   GraphQLInt,
   GraphQLScalarType,
+  GraphQLEnumType,
   ExecutionResult,
   print,
   buildSchema,
@@ -213,7 +214,7 @@ function createSubscriptionResolver(
   };
 }
 
-function createPassThroughScalar({
+export function createPassThroughScalar({
   name,
   description,
 }: {
@@ -235,6 +236,22 @@ function createPassThroughScalar({
   });
 }
 
+export function createPassThroughEnum(type: GraphQLEnumType) {
+  const values = type.getValues();
+  const newValues = {};
+
+  Object.keys(values).forEach(key => {
+    newValues[key] = values[key];
+  });
+
+  return new GraphQLEnumType({
+    name: type.name,
+    description: type.description,
+    astNode: type.astNode,
+    values: newValues,
+  });
+}
+
 function parseLiteral(ast: ValueNode): any {
   switch (ast.kind) {
     case Kind.STRING:

src/stitching/mergeSchemas.ts

@@ -7,6 +7,7 @@ import {
   GraphQLObjectType,
   GraphQLResolveInfo,
   GraphQLScalarType,
+  GraphQLEnumType,
   GraphQLSchema,
   GraphQLType,
   buildASTSchema,
@@ -16,6 +17,7 @@ import {
   isNamedType,
   parse,
 } from 'graphql';
+
 import TypeRegistry from './TypeRegistry';
 import { IResolvers, MergeInfo, IFieldResolver } from '../Interfaces';
 import isEmptyObject from '../isEmptyObject';
@@ -29,6 +31,7 @@ import {
 } from './schemaRecreation';
 import delegateToSchema from './delegateToSchema';
 import typeFromAST from './typeFromAST';
+import { createPassThroughScalar, createPassThroughEnum } from './makeRemoteExecutableSchema';
 
 const backcompatOptions = { commentDescriptions: true };
 
@@ -103,9 +106,14 @@ export default function mergeSchemas({
         let newType;
         if (isCompositeType(type) || type instanceof GraphQLInputObjectType) {
           newType = recreateCompositeType(schema, type, typeRegistry);
+        } else if (type instanceof GraphQLEnumType) {
+          newType = createPassThroughEnum(type);
+        } else if (type instanceof GraphQLScalarType) {
+          newType = createPassThroughScalar(type);
         } else {
           newType = getNamedType(type);
         }
+
         if (newType instanceof GraphQLObjectType) {
           delete newType.isTypeOf;
         }

src/test/testMergeSchemas.ts

@@ -10,19 +10,26 @@ import {
   parse,
   ExecutionResult,
 } from 'graphql';
+
+import { forAwaitEach } from 'iterall';
+
 import mergeSchemas from '../stitching/mergeSchemas';
+
 import {
   propertySchema as localPropertySchema,
   productSchema as localProductSchema,
   bookingSchema as localBookingSchema,
   subscriptionSchema as localSubscriptionSchema,
+  enumSchema as localEnumSchema,
+  resolveEnumType,
+  ENUM,
   remoteBookingSchema,
   remotePropertySchema,
   remoteProductSchema,
   subscriptionPubSub,
   subscriptionPubSubTrigger,
 } from './testingSchemas';
-import { forAwaitEach } from 'iterall';
+
 import { makeExecutableSchema } from '../schemaGenerator';
 
 const testCombinations = [
@@ -227,7 +234,7 @@ if (process.env.GRAPHQL_VERSION === '^0.11') {
 }
 
 testCombinations.forEach(async combination => {
-  describe('merging ' + combination.name, () => {
+  describe.only('merging ' + combination.name, () => {
     let mergedSchema: GraphQLSchema,
       propertySchema: GraphQLSchema,
       productSchema: GraphQLSchema,
@@ -248,6 +255,7 @@ testCombinations.forEach(async combination => {
           linkSchema,
           loneExtend,
           localSubscriptionSchema,
+          localEnumSchema,
         ],
         resolvers: {
           TestScalar: new GraphQLScalarType({
@@ -1140,7 +1148,7 @@ bookingById(id: "b1") {
       });
     });
 
-    describe('variables', () => {
+    describe.only('variables', () => {
       it('basic', async () => {
         const propertyFragment = `
           propertyById(id: $p1) {
@@ -1248,6 +1256,32 @@ bookingById(id: "b1") {
           },
         });
       });
+
+      it.only('with enum args', async () => {
+        const enumArg = 'VALUE_2';
+        const mergedResult = await graphql(
+          mergedSchema,
+          // language=GraphQL
+          `
+            query ($enumArg: EnumArgument!) {
+              enumType (enumArg: $enumArg) {
+                fieldA
+              }
+            }
+          `,
+          {},
+          {},
+          {
+            enumArg,
+          },
+        );
+
+        expect(mergedResult).to.deep.equal({
+          data: {
+            enumType: resolveEnumType(ENUM[enumArg]),
+          },
+        });
+      });
     });
 
     describe('aliases', () => {

src/test/testingSchemas.ts

@@ -7,13 +7,16 @@ import {
   GraphQLScalarType,
   ValueNode,
   ExecutionResult,
+  GraphQLObjectType,
+  GraphQLEnumType,
+  GraphQLString,
+  GraphQLNonNull,
 } from 'graphql';
+
 import { ApolloLink, Observable } from 'apollo-link';
 import { makeExecutableSchema } from '../schemaGenerator';
 import { IResolvers } from '../Interfaces';
-import makeRemoteExecutableSchema, {
-  Fetcher,
-} from '../stitching/makeRemoteExecutableSchema';
+import makeRemoteExecutableSchema, { Fetcher } from '../stitching/makeRemoteExecutableSchema';
 import introspectSchema from '../stitching/introspectSchema';
 import { PubSub } from 'graphql-subscriptions';
 
@@ -613,6 +616,58 @@ const subscriptionResolvers: IResolvers = {
   },
 };
 
+export const ENUM = {
+  VALUE_1: 1,
+  VALUE_2: 2,
+};
+
+const enumSchemaEnumType = new GraphQLEnumType({
+  name: 'EnumArgument',
+  values: {
+    VALUE_1: {
+      value: ENUM.VALUE_1,
+    },
+    VALUE_2: {
+      value: ENUM.VALUE_2,
+    },
+  },
+});
+
+const enumSchemaEnum = new GraphQLObjectType({
+  name: 'EnumType',
+  fields: () => ({
+    fieldA: {
+      type: GraphQLString,
+      resolve: parent => parent.fieldA,
+    },
+  }),
+});
+
+export const resolveEnumType = (enumArg: number) => {
+  return {
+    fieldA: `The enum arg was ${enumArg}`,
+  };
+};
+
+const enumSchemaQuery = new GraphQLObjectType({
+  name: 'Query',
+  fields: () => ({
+    enumType: {
+      type: enumSchemaEnum,
+      args: {
+        enumArg: {
+          type: new GraphQLNonNull(enumSchemaEnumType),
+        },
+      },
+      resolve: (root, args) => resolveEnumType(args.enumArg),
+    },
+  }),
+});
+
+export const enumSchema: GraphQLSchema = new GraphQLSchema({
+  query: enumSchemaQuery,
+});
+
 export const propertySchema: GraphQLSchema = makeExecutableSchema({
   typeDefs: propertyAddressTypeDefs,
   resolvers: propertyResolvers,