remove interface inheritance from validate directive combination rule

Author: a-alle

packages/graphql/src/schema/validation/custom-rules/valid-types/valid-directive-combination.ts

@@ -17,127 +17,31 @@
  * limitations under the License.
  */
 
-import type {
-    ASTVisitor,
-    DirectiveNode,
-    ASTNode,
-    InterfaceTypeDefinitionNode,
-    ObjectTypeDefinitionNode,
-    EnumTypeDefinitionNode,
-    EnumTypeExtensionNode,
-    EnumValueDefinitionNode,
-    FieldDefinitionNode,
-    FieldNode,
-    FragmentDefinitionNode,
-    FragmentSpreadNode,
-    InlineFragmentNode,
-    InputObjectTypeDefinitionNode,
-    InputObjectTypeExtensionNode,
-    InputValueDefinitionNode,
-    InterfaceTypeExtensionNode,
-    ObjectTypeExtensionNode,
-    OperationDefinitionNode,
-    ScalarTypeDefinitionNode,
-    ScalarTypeExtensionNode,
-    SchemaDefinitionNode,
-    SchemaExtensionNode,
-    UnionTypeDefinitionNode,
-    UnionTypeExtensionNode,
-    VariableDefinitionNode,
-} from "graphql";
+import type { ASTVisitor, DirectiveNode, ASTNode } from "graphql";
 import { Kind, isTypeDefinitionNode, isTypeExtensionNode } from "graphql";
 import type { SDLValidationContext } from "graphql/validation/ValidationContext";
 import { invalidCombinations } from "../../utils/invalid-directive-combinations";
 import { assertValid, createGraphQLError, DocumentValidationError } from "../utils/document-validation-error";
-import {
-    getInheritedTypeNames,
-    hydrateInterfaceWithImplementedTypesMap,
-} from "../utils/interface-to-implementing-types";
 import { getPathToNode } from "../utils/path-parser";
 
-type ASTNodeWithDirectives =
-    | OperationDefinitionNode
-    | VariableDefinitionNode
-    | FieldNode
-    | FragmentSpreadNode
-    | InlineFragmentNode
-    | FragmentDefinitionNode
-    | SchemaDefinitionNode
-    | ScalarTypeDefinitionNode
-    | ObjectTypeDefinitionNode
-    | FieldDefinitionNode
-    | InputValueDefinitionNode
-    | InterfaceTypeDefinitionNode
-    | UnionTypeDefinitionNode
-    | EnumTypeDefinitionNode
-    | EnumValueDefinitionNode
-    | InputObjectTypeDefinitionNode
-    | SchemaExtensionNode
-    | ScalarTypeExtensionNode
-    | ObjectTypeExtensionNode
-    | InterfaceTypeExtensionNode
-    | UnionTypeExtensionNode
-    | EnumTypeExtensionNode
-    | InputObjectTypeExtensionNode;
 export function DirectiveCombinationValid(context: SDLValidationContext): ASTVisitor {
-    const interfaceToImplementingTypes = new Map<string, Set<string>>();
-    const typeToDirectivesPerFieldMap = new Map<string, Map<string, readonly DirectiveNode[]>>();
-    const typeToDirectivesMap = new Map<string, readonly DirectiveNode[]>();
-    const hydrateWithDirectives = function (
-        node: ASTNodeWithDirectives,
-        parentOfTraversedDef: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | undefined
-    ) {
-        if (node.kind === Kind.OBJECT_TYPE_DEFINITION || node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
-            typeToDirectivesMap.set(node.name.value, node.directives || []);
-        }
-        if (node.kind === Kind.FIELD_DEFINITION) {
-            if (!parentOfTraversedDef) {
-                return;
-            }
-            const seenFields =
-                typeToDirectivesPerFieldMap.get(parentOfTraversedDef.name.value) ||
-                new Map<string, readonly DirectiveNode[]>();
-            seenFields.set(node.name.value, node.directives || []);
-            typeToDirectivesPerFieldMap.set(parentOfTraversedDef.name.value, seenFields);
-        }
-    };
-    const getDirectives = function (
-        node: ASTNodeWithDirectives,
-        parentOfTraversedDef: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | undefined
-    ): DirectiveNode[] {
-        const directivesToCheck: DirectiveNode[] = [...(node.directives || [])];
-        if (node.kind === Kind.OBJECT_TYPE_DEFINITION || node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
-            return getInheritedTypeNames(node, interfaceToImplementingTypes).reduce((acc, i) => {
-                const inheritedDirectives = typeToDirectivesMap.get(i) || [];
-                return acc.concat(inheritedDirectives);
-            }, directivesToCheck);
-        }
-        if (node.kind === Kind.FIELD_DEFINITION) {
-            if (!parentOfTraversedDef) {
-                return [];
-            }
-            return getInheritedTypeNames(parentOfTraversedDef, interfaceToImplementingTypes).reduce((acc, i) => {
-                const inheritedDirectives = typeToDirectivesPerFieldMap.get(i)?.get(node.name.value) || [];
-                return acc.concat(inheritedDirectives);
-            }, directivesToCheck);
-        }
-        return directivesToCheck;
-    };
-
     return {
         enter(node: ASTNode, _key, _parent, path, ancestors) {
             if (!("directives" in node) || !node.directives) {
                 return;
             }
-            const [pathToNode, traversedDef, parentOfTraversedDef] = getPathToNode(path, ancestors);
+            const [pathToNode, traversedDef] = getPathToNode(path, ancestors);
             const currentNodeErrorPath =
                 isTypeDefinitionNode(node) || isTypeExtensionNode(node) ? [...pathToNode, node.name.value] : pathToNode;
 
-            hydrateInterfaceWithImplementedTypesMap(node, interfaceToImplementingTypes);
-            hydrateWithDirectives(node, parentOfTraversedDef);
-            const directivesToCheck = getDirectives(node, parentOfTraversedDef);
+            if (node.directives.length < 2) {
+                // no directive combination to check
+                return;
+            }
 
-            const { isValid, errorMsg, errorPath } = assertValid(() => assertValidDirectives(directivesToCheck));
+            const { isValid, errorMsg, errorPath } = assertValid(() =>
+                assertValidDirectives(node.directives as DirectiveNode[])
+            );
             if (!isValid) {
                 context.reportError(
                     createGraphQLError({