Validate directives and allow to overwrite specified directives

.changeset/healthy-hornets-collect.md

@@ -0,0 +1,5 @@
+---
+'@theguild/federation-composition': patch
+---
+
+fix: allow to overwrite specified directives

.changeset/rude-boxes-mate.md

@@ -0,0 +1,5 @@
+---
+'@theguild/federation-composition': minor
+---
+
+Validate directive definitions

__tests__/subgraph/errors/INVALID_GRAPHQL.spec.ts

@@ -439,4 +439,38 @@ testVersions((api, version) => {
       }),
     );
   });
+
+  test('directive overwritten specified directive (like @deprecated) on wrong location', () => {
+    assertCompositionFailure(
+      api.composeServices([
+        {
+          name: 'mono',
+          typeDefs: graphql`
+            schema
+              @link(url: "https://specs.apollo.dev/link/v1.0")
+              @link(url: "https://specs.apollo.dev/federation/${version}", import: ["@shareable"]) {
+              query: Query
+            }
+
+            directive @deprecated(reason: String = "No longer supported") on FIELD_DEFINITION
+
+            directive @shareable repeatable on OBJECT | FIELD_DEFINITION
+
+            type Query @shareable {
+              view(input: Input): View!
+            }
+
+            type View @shareable {
+              user: String
+              post: String!
+            }
+
+            input Input {
+              input: String @deprecated(reason: "impossibru")
+            }
+          `,
+        },
+      ]),
+    );
+  });
 });

src/subgraph/validation/rules/known-directives-rule.ts

@@ -23,10 +23,13 @@ export function KnownDirectivesRule(context: {
   }
 
   for (const specifiedDirective of specifiedDirectives) {
-    locationsMap.set(
-      specifiedDirective.name,
-      new Set(specifiedDirective.locations.map(loc => String(loc))),
-    );
+    // If the directive is already defined by the schema, leave it be.
+    if (!locationsMap.has(specifiedDirective.name)) {
+      locationsMap.set(
+        specifiedDirective.name,
+        new Set(specifiedDirective.locations.map(loc => String(loc))),
+      );
+    }
   }
 
   return {

src/subgraph/validation/validate-state.ts

@@ -16,6 +16,7 @@ import {
 } from '../../utils/state.js';
 import {
   Argument,
+  Directive,
   EnumType,
   InputField,
   InputObjectType,
@@ -46,7 +47,7 @@ export function validateSubgraphState(state: SubgraphState) {
   }
 
   validateRootTypes(state, reportError);
-  // validateDirectives(state, reportError); + default values there
+  validateDirectives(state, reportError);
   validateTypes(state, reportError);
 
   return errors;
@@ -102,6 +103,35 @@ function capitalize(str: string): string {
   return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
 }
 
+function validateDirectives(state: SubgraphState, reportError: ReportErrorFn): void {
+  for (const directive of state.types.values()) {
+    if (isDirective(directive)) {
+      // Ensure they are named correctly.
+      validateName(reportError, directive.name);
+
+      // Ensure the arguments are valid.
+      for (const [argName, arg] of directive.args) {
+        // Ensure they are named correctly.
+        validateName(reportError, argName);
+
+        // Ensure the type is an input type.
+        const argInputTypeName = stripTypeModifiers(arg.type);
+
+        if (!isInputType(state, argInputTypeName)) {
+          reportError(
+            `The type of @${directive.name}(${arg.name}:) must be Input Type ` +
+              `but got: ${arg.type}.`,
+          );
+        }
+
+        if (isRequiredArgument(arg) && arg.deprecated?.deprecated === true) {
+          reportError(`Required argument @${directive.name}(${arg.name}:) cannot be deprecated.`);
+        }
+      }
+    }
+  }
+}
+
 function validateTypes(state: SubgraphState, reportError: ReportErrorFn): void {
   const validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(
     state,
@@ -784,3 +814,7 @@ export function isInterfaceType(type: SubgraphType): type is InterfaceType {
 export function isUnionType(type: SubgraphType): type is UnionType {
   return type.kind === TypeKind.UNION;
 }
+
+export function isDirective(type: SubgraphType): type is Directive {
+  return type.kind === TypeKind.DIRECTIVE;
+}