fix(stitching): avoid duplicate directives

packages/stitch/src/stitchSchemas.ts

@@ -10,14 +10,7 @@ import {
   GraphQLNamedType,
 } from 'graphql';
 
-import {
-  SchemaDirectiveVisitor,
-  cloneDirective,
-  mergeDeep,
-  IResolvers,
-  rewireTypes,
-  pruneSchema,
-} from '@graphql-tools/utils';
+import { SchemaDirectiveVisitor, mergeDeep, IResolvers, rewireTypes, pruneSchema } from '@graphql-tools/utils';
 
 import {
   addResolversToSchema,
@@ -58,29 +51,51 @@ export function stitchSchemas({
     throw new Error('Expected `resolverValidationOptions` to be an object');
   }
 
+  schemas.forEach(schemaLikeObject => {
+    if (
+      !isSchema(schemaLikeObject) &&
+      !isSubschemaConfig(schemaLikeObject) &&
+      typeof schemaLikeObject !== 'string' &&
+      !isDocumentNode(schemaLikeObject) &&
+      !Array.isArray(schemaLikeObject)
+    ) {
+      throw new Error('Invalid schema passed');
+    }
+  });
+
   let schemaLikeObjects: Array<GraphQLSchema | SubschemaConfig | DocumentNode | GraphQLNamedType> = [...subschemas];
+  schemas.forEach(schemaLikeObject => {
+    if (isSchema(schemaLikeObject) || isSubschemaConfig(schemaLikeObject)) {
+      schemaLikeObjects.push(schemaLikeObject);
+    }
+  });
+
   if ((typeDefs && !Array.isArray(typeDefs)) || (Array.isArray(typeDefs) && typeDefs.length)) {
     schemaLikeObjects.push(buildDocumentFromTypeDefinitions(typeDefs, parseOptions));
   }
+  schemas.forEach(schemaLikeObject => {
+    if (typeof schemaLikeObject === 'string' || isDocumentNode(schemaLikeObject)) {
+      schemaLikeObjects.push(buildDocumentFromTypeDefinitions(schemaLikeObject, parseOptions));
+    }
+  });
+
   if (types != null) {
     schemaLikeObjects = schemaLikeObjects.concat(types);
   }
   schemas.forEach(schemaLikeObject => {
-    if (isSchema(schemaLikeObject) || isSubschemaConfig(schemaLikeObject)) {
-      schemaLikeObjects.push(schemaLikeObject);
-    } else if (typeof schemaLikeObject === 'string' || isDocumentNode(schemaLikeObject)) {
-      schemaLikeObjects.push(buildDocumentFromTypeDefinitions(schemaLikeObject, parseOptions));
-    } else if (Array.isArray(schemaLikeObject)) {
+    if (Array.isArray(schemaLikeObject)) {
       schemaLikeObjects = schemaLikeObjects.concat(schemaLikeObject);
-    } else {
-      throw new Error('Invalid schema passed');
     }
   });
 
   const transformedSchemas: Map<GraphQLSchema | SubschemaConfig, GraphQLSchema> = new Map();
   const typeCandidates: Record<string, Array<MergeTypeCandidate>> = Object.create(null);
   const extensions: Array<DocumentNode> = [];
   const directives: Array<GraphQLDirective> = [];
+  const directiveMap: Record<string, GraphQLDirective> = specifiedDirectives.reduce((acc, directive) => {
+    acc[directive.name] = directive;
+    return acc;
+  }, Object.create(null));
   const schemaDefs = Object.create(null);
   const operationTypeNames = {
     query: 'Query',
@@ -93,12 +108,16 @@ export function stitchSchemas({
     transformedSchemas,
     typeCandidates,
     extensions,
-    directives,
+    directiveMap,
     schemaDefs,
     operationTypeNames,
     mergeDirectives,
   });
 
+  Object.keys(directiveMap).forEach(directiveName => {
+    directives.push(directiveMap[directiveName]);
+  });
+
   let stitchingInfo: StitchingInfo;
 
   stitchingInfo = createStitchingInfo(transformedSchemas, typeCandidates, mergeTypes);
@@ -118,9 +137,7 @@ export function stitchSchemas({
     mutation: newTypeMap[operationTypeNames.mutation] as GraphQLObjectType,
     subscription: newTypeMap[operationTypeNames.subscription] as GraphQLObjectType,
     types: Object.keys(newTypeMap).map(key => newTypeMap[key]),
-    directives: newDirectives.length
-      ? specifiedDirectives.slice().concat(newDirectives.map(directive => cloneDirective(directive)))
-      : undefined,
+    directives: newDirectives,
     astNode: schemaDefs.schemaDef,
     extensionASTNodes: schemaDefs.schemaExtensions,
     extensions: null,

packages/stitch/src/typeCandidates.ts

@@ -39,7 +39,7 @@ export function buildTypeCandidates({
   transformedSchemas,
   typeCandidates,
   extensions,
-  directives,
+  directiveMap,
   schemaDefs,
   operationTypeNames,
   mergeDirectives,
@@ -48,7 +48,7 @@ export function buildTypeCandidates({
   transformedSchemas: Map<GraphQLSchema | SubschemaConfig, GraphQLSchema>;
   typeCandidates: Record<string, Array<MergeTypeCandidate>>;
   extensions: Array<DocumentNode>;
-  directives: Array<GraphQLDirective>;
+  directiveMap: Record<string, GraphQLDirective>;
   schemaDefs: {
     schemaDef: SchemaDefinitionNode;
     schemaExtensions: Array<SchemaExtensionNode>;
@@ -96,7 +96,7 @@ export function buildTypeCandidates({
 
       if (mergeDirectives) {
         schema.getDirectives().forEach(directive => {
-          directives.push(directive);
+          directiveMap[directive.name] = directive;
         });
       }
 
@@ -131,7 +131,8 @@ export function buildTypeCandidates({
 
       const directivesDocument = extractDirectiveDefinitions(schemaLikeObject);
       directivesDocument.definitions.forEach(def => {
-        directives.push(typeFromAST(def) as GraphQLDirective);
+        const directive = typeFromAST(def) as GraphQLDirective;
+        directiveMap[directive.name] = directive;
       });
 
       const extensionsDocument = extractTypeExtensionDefinitions(schemaLikeObject);

packages/utils/src/rewire.ts

@@ -23,6 +23,7 @@ import {
   isScalarType,
   isUnionType,
   isSpecifiedScalarType,
+  isSpecifiedDirective,
 } from 'graphql';
 
 import { getBuiltInForStub, isNamedStub } from './stub';
@@ -78,6 +79,9 @@ export function rewireTypes(
     : pruneTypes(newTypeMap, newDirectives);
 
   function rewireDirective(directive: GraphQLDirective): GraphQLDirective {
+    if (isSpecifiedDirective(directive)) {
+      return directive;
+    }
     const directiveConfig = directive.toConfig();
     directiveConfig.args = rewireArgs(directiveConfig.args);
     return new GraphQLDirective(directiveConfig);