@wundergraph/composition 0.35.0 → 0.36.1

package/dist/normalization/normalization-factory.js

@@ -41,7 +41,9 @@ class NormalizationFactory {
     conditionalFieldDataByCoordinates = new Map();
     configurationDataByParentTypeName = new Map();
     customDirectiveDefinitions = new Map();
+    definedDirectiveNames = new Set();
     directiveDefinitionByDirectiveName = new Map();
+    directiveDefinitionDataByDirectiveName = (0, utils_2.initializeDirectiveDefinitionDatas)();
     edfsDirectiveReferences = new Set();
     errors = [];
     entityDataByTypeName = new Map();
@@ -50,12 +52,15 @@ class NormalizationFactory {
     unvalidatedExternalFieldCoords = new Set();
     interfaceTypeNamesWithAuthorizationDirectives = new Set();
     internalGraph;
+    invalidConfigureDescriptionNodeDatas = [];
+    invalidRepeatedDirectiveNameByCoords = new Map();
     isCurrentParentExtension = false;
+    isParentObjectExternal = false;
+    isParentObjectShareable = false;
     isSubgraphEventDrivenGraph = false;
     isSubgraphVersionTwo = false;
     fieldSetDataByTypeName = new Map();
     heirFieldAuthorizationDataByTypeName = new Map();
-    handledRepeatedDirectivesByHostPath = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
     lastChildNodeKind = graphql_1.Kind.NULL;
     leafTypeNamesWithAuthorizationDirectives = new Set();
@@ -68,7 +73,7 @@ class NormalizationFactory {
     parentsWithChildArguments = new Set();
     overridesByTargetSubgraphName = new Map();
     invalidOrScopesHostPaths = new Set();
-    schemaDefinition;
+    schemaData;
     referencedDirectiveNames = new Set();
     referencedTypeNames = new Set();
     renamedParentTypeName = '';
@@ -82,10 +87,10 @@ class NormalizationFactory {
         this.subgraphName = subgraphName || string_constants_1.NOT_APPLICABLE;
         this.internalGraph = internalGraph;
         this.internalGraph.setSubgraphName(this.subgraphName);
-        this.schemaDefinition = {
+        this.schemaData = {
             directivesByDirectiveName: new Map(),
             kind: graphql_1.Kind.SCHEMA_DEFINITION,
-            typeName: string_constants_1.SCHEMA,
+            name: string_constants_1.SCHEMA,
             operationTypes: new Map(),
         };
     }
@@ -201,104 +206,271 @@ class NormalizationFactory {
         }
         return authorizationData;
     }
-    extractDirectivesAndAuthorization(node, directivesByDirectiveName) {
+    isTypeNameRootType(typeName) {
+        return string_constants_1.ROOT_TYPE_NAMES.has(typeName) || this.operationTypeNodeByTypeName.has(typeName);
+    }
+    isArgumentValueValid(typeNode, argumentValue) {
+        if (argumentValue.kind === graphql_1.Kind.NULL) {
+            return typeNode.kind !== graphql_1.Kind.NON_NULL_TYPE;
+        }
+        switch (typeNode.kind) {
+            case graphql_1.Kind.LIST_TYPE: {
+                if (argumentValue.kind !== graphql_1.Kind.LIST) {
+                    // This handles List coercion
+                    return this.isArgumentValueValid((0, ast_1.getNamedTypeNode)(typeNode.type), argumentValue);
+                }
+                for (const value of argumentValue.values) {
+                    if (!this.isArgumentValueValid(typeNode.type, value)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case graphql_1.Kind.NAMED_TYPE: {
+                switch (typeNode.name.value) {
+                    case string_constants_1.BOOLEAN_SCALAR: {
+                        return argumentValue.kind === graphql_1.Kind.BOOLEAN;
+                    }
+                    case string_constants_1.FLOAT_SCALAR: {
+                        return argumentValue.kind === graphql_1.Kind.FLOAT || argumentValue.kind === graphql_1.Kind.INT;
+                    }
+                    case string_constants_1.ID_SCALAR: {
+                        return argumentValue.kind === graphql_1.Kind.STRING || argumentValue.kind === graphql_1.Kind.INT;
+                    }
+                    case string_constants_1.INT_SCALAR: {
+                        return argumentValue.kind === graphql_1.Kind.INT;
+                    }
+                    case string_constants_1.FIELD_SET_SCALAR:
+                    // intentional fallthrough
+                    case string_constants_1.SCOPE_SCALAR:
+                    // intentional fallthrough
+                    case string_constants_1.STRING_SCALAR: {
+                        return argumentValue.kind === graphql_1.Kind.STRING;
+                    }
+                    case string_constants_1.LINK_IMPORT: {
+                        return true;
+                    }
+                    case string_constants_1.LINK_PURPOSE: {
+                        if (argumentValue.kind !== graphql_1.Kind.ENUM) {
+                            return false;
+                        }
+                        return argumentValue.value === string_constants_1.SECURITY || argumentValue.value === string_constants_1.EXECUTION;
+                    }
+                    case string_constants_1.SUBSCRIPTION_FIELD_CONDITION:
+                    // intentional fallthrough
+                    case string_constants_1.SUBSCRIPTION_FILTER_CONDITION:
+                        return argumentValue.kind === graphql_1.Kind.OBJECT;
+                    default: {
+                        const parentData = this.parentDefinitionDataByTypeName.get(typeNode.name.value);
+                        if (!parentData) {
+                            return false;
+                        }
+                        if (parentData.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
+                            // For now, allow custom scalars to be any value kind.
+                            return true;
+                        }
+                        if (parentData.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
+                            if (argumentValue.kind !== graphql_1.Kind.ENUM) {
+                                return false;
+                            }
+                            const enumValue = parentData.enumValueDataByValueName.get(argumentValue.value);
+                            if (!enumValue) {
+                                return false;
+                            }
+                            return !enumValue.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+                        }
+                        if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                            return false;
+                        }
+                        // TODO deep comparison
+                        return argumentValue.kind === graphql_1.Kind.OBJECT;
+                    }
+                }
+            }
+            default: {
+                return this.isArgumentValueValid(typeNode.type, argumentValue);
+            }
+        }
+    }
+    addInheritedDirectivesToFieldData(fieldDirectivesByDirectiveName) {
+        if (this.isParentObjectShareable) {
+            (0, utils_3.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_1.SHAREABLE, () => [(0, utils_3.generateSimpleDirective)(string_constants_1.SHAREABLE)]);
+        }
+        if (this.isParentObjectExternal) {
+            (0, utils_3.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_1.EXTERNAL, () => [(0, utils_3.generateSimpleDirective)(string_constants_1.EXTERNAL)]);
+        }
+        return fieldDirectivesByDirectiveName;
+    }
+    extractDirectives(node, directivesByDirectiveName) {
         if (!node.directives) {
             return directivesByDirectiveName;
         }
-        const hostPath = this.childName ? `${this.originalParentTypeName}.${this.childName}` : this.originalParentTypeName;
-        const authorizationDirectives = [];
         for (const directiveNode of node.directives) {
-            const errorMessages = (0, utils_4.getDirectiveValidationErrors)(directiveNode, node.kind, directivesByDirectiveName, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, hostPath);
             const directiveName = directiveNode.name.value;
-            if (errorMessages.length > 0) {
-                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
+            // Don't create pointless repetitions of @shareable
+            if (directiveName === string_constants_1.SHAREABLE) {
+                (0, utils_3.getValueOrDefault)(directivesByDirectiveName, directiveName, () => [directiveNode]);
+            }
+            else {
+                (0, utils_3.getValueOrDefault)(directivesByDirectiveName, directiveName, () => []).push(directiveNode);
+            }
+            if (!(0, utils_3.isNodeKindObject)(node.kind)) {
                 continue;
             }
-            if (directiveName === string_constants_1.EXTENDS) {
+            this.isParentObjectExternal ||= directiveName === string_constants_1.EXTERNAL;
+            this.isParentObjectShareable ||= directiveName === string_constants_1.SHAREABLE;
+        }
+        return directivesByDirectiveName;
+    }
+    validateDirective({ data, definitionData, directiveCoords, directiveNode, errorMessages, requiredArgumentNames, }) {
+        const directiveName = directiveNode.name.value;
+        const parentTypeName = data.kind === graphql_1.Kind.FIELD_DEFINITION ? data.renamedParentTypeName || data.originalParentTypeName : data.name;
+        const isAuthenticated = directiveName === string_constants_1.AUTHENTICATED;
+        const isOverride = directiveName === string_constants_1.OVERRIDE;
+        const isRequiresScopes = directiveName === string_constants_1.REQUIRES_SCOPES;
+        if (!directiveNode.arguments || directiveNode.arguments.length < 1) {
+            if (definitionData.requiredArgumentNames.size > 0) {
+                errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, requiredArgumentNames, []));
+            }
+            if (isAuthenticated) {
+                this.handleAuthenticatedDirective(data, parentTypeName);
+            }
+            return errorMessages;
+        }
+        const definedArgumentNames = new Set();
+        const duplicateArgumentNames = new Set();
+        const unexpectedArgumentNames = new Set();
+        const requiredScopes = [];
+        for (const argumentNode of directiveNode.arguments) {
+            const argumentName = argumentNode.name.value;
+            if (definedArgumentNames.has(argumentName)) {
+                duplicateArgumentNames.add(argumentName);
                 continue;
             }
-            if (directiveName === string_constants_1.OVERRIDE) {
-                this.handleOverrideDeclaration(directiveNode, hostPath, errorMessages);
-                if (errorMessages.length > 0) {
-                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
-                }
+            definedArgumentNames.add(argumentName);
+            const argumentData = definitionData.argumentTypeNodeByArgumentName.get(argumentName);
+            if (!argumentData) {
+                unexpectedArgumentNames.add(argumentName);
                 continue;
             }
-            if (directiveName === string_constants_1.AUTHENTICATED || directiveName === string_constants_1.REQUIRES_SCOPES) {
-                authorizationDirectives.push(directiveNode);
+            if (!this.isArgumentValueValid(argumentData.typeNode, argumentNode.value)) {
+                errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(argumentNode.value), `@${directiveName}`, argumentName, (0, merge_1.printTypeNode)(argumentData.typeNode)));
                 continue;
             }
-            const existingDirectives = directivesByDirectiveName.get(directiveName);
-            if (existingDirectives) {
-                existingDirectives.push(directiveNode);
+            // The directive location validation means the kind check should be unnecessary
+            if (isOverride && data.kind === graphql_1.Kind.FIELD_DEFINITION) {
+                this.handleOverrideDirective({
+                    data,
+                    directiveCoords,
+                    errorMessages,
+                    targetSubgraphName: argumentNode.value.value,
+                });
+                continue;
+            }
+            if (!isRequiresScopes || argumentName !== string_constants_1.SCOPES) {
                 continue;
             }
-            directivesByDirectiveName.set(directiveName, [directiveNode]);
+            this.handleRequiresScopesDirective({
+                directiveCoords,
+                // Casts are safe because invalid arguments would short circuit
+                orScopes: argumentNode.value.values,
+                requiredScopes,
+            });
         }
-        if (authorizationDirectives.length < 1) {
-            return directivesByDirectiveName;
+        if (duplicateArgumentNames.size > 0) {
+            errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionsErrorMessage)([...duplicateArgumentNames]));
         }
-        const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
-        if (node.kind !== graphql_1.Kind.FIELD_DEFINITION) {
+        if (unexpectedArgumentNames.size > 0) {
+            errorMessages.push((0, errors_1.unexpectedDirectiveArgumentErrorMessage)(directiveName, [...unexpectedArgumentNames]));
+        }
+        const undefinedArgumentNames = (0, utils_3.getEntriesNotInHashSet)(requiredArgumentNames, definedArgumentNames);
+        if (undefinedArgumentNames.length > 0) {
+            errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, requiredArgumentNames, undefinedArgumentNames));
+        }
+        if (errorMessages.length > 0 || !isRequiresScopes) {
+            return errorMessages;
+        }
+        if (data.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION &&
+            data.kind !== graphql_1.Kind.FIELD_DEFINITION &&
+            data.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
+            return errorMessages;
+        }
+        if (data.kind !== graphql_1.Kind.FIELD_DEFINITION) {
             this.leafTypeNamesWithAuthorizationDirectives.add(parentTypeName);
         }
         const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, parentTypeName, () => (0, utils_3.newAuthorizationData)(parentTypeName));
-        const authorizationData = (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, node, this.childName);
-        for (const directiveNode of authorizationDirectives) {
-            const directiveName = directiveNode.name.value;
-            if (directiveName === string_constants_1.AUTHENTICATED) {
-                authorizationData.requiresAuthentication = true;
+        const authorizationData = (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, data.node);
+        authorizationData.requiredScopes.push(...requiredScopes);
+        return errorMessages;
+    }
+    validateDirectives(data, directiveCoords) {
+        const undefinedDirectiveNames = new Set();
+        for (const [directiveName, directiveNodes] of data.directivesByDirectiveName) {
+            const definitionData = this.directiveDefinitionDataByDirectiveName.get(directiveName);
+            if (!definitionData) {
+                if (!undefinedDirectiveNames.has(directiveName)) {
+                    this.errors.push((0, errors_1.undefinedDirectiveError)(directiveName, directiveCoords));
+                    undefinedDirectiveNames.add(directiveName);
+                }
                 continue;
             }
-            const orScopes = directiveNode.arguments[0].value.values;
-            if (orScopes.length > utils_3.maxOrScopes) {
-                this.invalidOrScopesHostPaths.add(hostPath);
-                continue;
+            const definitionErrorMessages = [];
+            const directiveLocation = (0, utils_1.nodeKindToDirectiveLocation)(data.kind);
+            if (!definitionData.locations.has(directiveLocation)) {
+                definitionErrorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(directiveName, directiveLocation));
             }
-            for (const scopes of orScopes) {
-                const andScopes = new Set();
-                for (const scope of scopes.values) {
-                    andScopes.add(scope.value);
+            if (directiveNodes.length > 1 && !definitionData.isRepeatable) {
+                const handledDirectiveNames = (0, utils_3.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
+                if (!handledDirectiveNames.has(directiveName)) {
+                    handledDirectiveNames.add(directiveName);
+                    definitionErrorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName));
                 }
-                if (andScopes.size) {
-                    authorizationData.requiredScopes.push(andScopes);
+            }
+            const requiredArgumentNames = [...definitionData.requiredArgumentNames];
+            for (let i = 0; i < directiveNodes.length; i++) {
+                const errorMessages = this.validateDirective({
+                    data,
+                    directiveNode: directiveNodes[i],
+                    definitionData,
+                    directiveCoords,
+                    errorMessages: i < 1 ? definitionErrorMessages : [],
+                    requiredArgumentNames,
+                });
+                if (errorMessages.length > 0) {
+                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, directiveCoords, (0, utils_3.numberToOrdinal)(i + 1), errorMessages));
                 }
             }
         }
-        return directivesByDirectiveName;
-    }
-    isTypeNameRootType(typeName) {
-        return string_constants_1.ROOT_TYPE_NAMES.has(typeName) || this.operationTypeNodeByTypeName.has(typeName);
-    }
-    extractDirectives(node, directivesByDirectiveName, hostPath, isArgument = false) {
-        if (!node.directives) {
-            return directivesByDirectiveName;
-        }
-        const entityKeys = new Set();
-        for (const directiveNode of node.directives) {
-            const errorMessages = (0, utils_4.getDirectiveValidationErrors)(directiveNode, node.kind, directivesByDirectiveName, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, hostPath, isArgument);
-            const directiveName = directiveNode.name.value;
-            if (errorMessages.length > 0) {
-                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
-                continue;
+        switch (data.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION: {
+                for (const [enumValueName, enumValueData] of data.enumValueDataByValueName) {
+                    this.validateDirectives(enumValueData, `${data.name}.${enumValueName}`);
+                }
+                return;
             }
-            if (string_constants_1.IGNORED_PARENT_DIRECTIVES.has(directiveName)) {
-                continue;
+            case graphql_1.Kind.FIELD_DEFINITION: {
+                for (const [argumentName, argumentData] of data.argumentDataByArgumentName) {
+                    this.validateDirectives(argumentData, `${data.originalParentTypeName}.${data.name}(${argumentName}: ...)`);
+                }
+                return;
             }
-            if (directiveName === string_constants_1.KEY) {
-                // The argument was validated earlier
-                const entityKey = directiveNode.arguments[0].value.value;
-                if (entityKeys.has(entityKey)) {
-                    continue;
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+                for (const [inputValueName, inputValueData] of data.inputValueDataByValueName) {
+                    this.validateDirectives(inputValueData, `${data.name}.${inputValueName}`);
                 }
-                entityKeys.add(entityKey);
+                return;
             }
-            const existingDirectives = directivesByDirectiveName.get(directiveName);
-            existingDirectives
-                ? existingDirectives.push(directiveNode)
-                : directivesByDirectiveName.set(directiveName, [directiveNode]);
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            // intentional fallthrough
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION: {
+                for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
+                    this.validateDirectives(fieldData, `${data.name}.${fieldName}`);
+                }
+                return;
+            }
+            default:
+                return;
         }
-        return directivesByDirectiveName;
     }
     /* ExtensionType uses a trichotomy rather than a boolean because @extends is still a definition.
      * A definition and another definition with @extends would still be an error, so it cannot be treated
@@ -338,6 +510,57 @@ class NormalizationFactory {
             }
         }
     }
+    extractConfigureDescriptionData(data, directiveNode) {
+        if (!directiveNode.arguments || directiveNode.arguments.length < 1) {
+            if (!data.description) {
+                this.invalidConfigureDescriptionNodeDatas.push(data);
+            }
+            data.configureDescriptionDataBySubgraphName.set(this.subgraphName, {
+                propagate: true,
+                description: data.description?.value || '',
+            });
+            return;
+        }
+        const configureDescriptionData = {
+            propagate: true,
+            description: data.description?.value || '',
+        };
+        for (const argument of directiveNode.arguments) {
+            switch (argument.name.value) {
+                case string_constants_1.PROPAGATE: {
+                    if (argument.value.kind != graphql_1.Kind.BOOLEAN) {
+                        return;
+                    }
+                    configureDescriptionData.propagate = argument.value.value;
+                    break;
+                }
+                case string_constants_1.DESCRIPTION_OVERRIDE: {
+                    if (argument.value.kind != graphql_1.Kind.STRING) {
+                        return;
+                    }
+                    configureDescriptionData.description = argument.value.value;
+                    break;
+                }
+                default: {
+                    return;
+                }
+            }
+        }
+        if (!data.description && !configureDescriptionData.description) {
+            this.invalidConfigureDescriptionNodeDatas.push(data);
+        }
+        data.configureDescriptionDataBySubgraphName.set(this.subgraphName, configureDescriptionData);
+    }
+    extractConfigureDescriptionsData(data) {
+        const configureDescriptionNodes = data.directivesByDirectiveName.get(string_constants_1.CONFIGURE_DESCRIPTION);
+        if (configureDescriptionNodes && configureDescriptionNodes.length == 1) {
+            this.extractConfigureDescriptionData(data, configureDescriptionNodes[0]);
+        }
+        // TODO configureChildDescriptions will be added in another PR
+        // const configureChildDescriptionsNodes = data.directivesByDirectiveName.get(CONFIGURE_CHILD_DESCRIPTIONS);
+        // if (configureChildDescriptionsNodes && configureChildDescriptionsNodes.length == 1) {
+        // }
+    }
     extractImplementedInterfaceTypeNames(node, implementedInterfaceTypeNames) {
         if (!node.interfaces) {
             return implementedInterfaceTypeNames;
@@ -353,13 +576,14 @@ class NormalizationFactory {
         }
         return implementedInterfaceTypeNames;
     }
-    updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType) {
-        this.setParentDataExtensionType(parentData, extensionType);
-        this.extractImplementedInterfaceTypeNames(node, parentData.implementedInterfaceTypeNames);
-        parentData.isEntity ||= directivesByDirectiveName.has(string_constants_1.KEY);
-        parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
-        parentData.subgraphNames.add(this.subgraphName);
-        parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+    updateCompositeOutputDataByNode(node, data, extensionType) {
+        this.setParentDataExtensionType(data, extensionType);
+        this.extractImplementedInterfaceTypeNames(node, data.implementedInterfaceTypeNames);
+        data.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+        this.extractConfigureDescriptionsData(data);
+        data.isEntity ||= data.directivesByDirectiveName.has(string_constants_1.KEY);
+        data.isInaccessible ||= data.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+        data.subgraphNames.add(this.subgraphName);
     }
     addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames, concreteTypeName) {
         for (const interfaceName of interfaceTypeNames) {
@@ -367,10 +591,196 @@ class NormalizationFactory {
             this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(interfaceName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(concreteTypeName), concreteTypeName, true);
         }
     }
+    extractArguments(argumentDataByArgumentName, node) {
+        if (!node.arguments?.length) {
+            return argumentDataByArgumentName;
+        }
+        const fieldName = node.name.value;
+        const originalFieldPath = `${this.originalParentTypeName}.${fieldName}`;
+        const renamedFieldPath = `${this.renamedParentTypeName}.${fieldName}`;
+        this.parentsWithChildArguments.add(this.originalParentTypeName);
+        const duplicatedArguments = new Set();
+        for (const argumentNode of node.arguments) {
+            const argumentName = argumentNode.name.value;
+            if (argumentDataByArgumentName.has(argumentName)) {
+                duplicatedArguments.add(argumentName);
+                continue;
+            }
+            this.addInputValueDataByNode(argumentDataByArgumentName, argumentNode, `${originalFieldPath}(${argumentName}: ...)`, `${renamedFieldPath}(${argumentName}: ...)`);
+        }
+        if (duplicatedArguments.size > 0) {
+            this.errors.push((0, errors_1.duplicateArgumentsError)(originalFieldPath, [...duplicatedArguments]));
+        }
+        return argumentDataByArgumentName;
+    }
+    addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName, node, executableLocations) {
+        const name = node.name.value;
+        const argumentDataByArgumentName = new Map();
+        for (const argumentNode of node.arguments || []) {
+            const originalPath = `@${name}(${argumentNode.name.value}: ...)`;
+            this.addInputValueDataByNode(argumentDataByArgumentName, argumentNode, originalPath, originalPath);
+        }
+        persistedDirectiveDefinitionDataByDirectiveName.set(name, {
+            argumentDataByArgumentName,
+            executableLocations,
+            name,
+            repeatable: node.repeatable,
+            subgraphNames: new Set([this.subgraphName]),
+            description: (0, utils_1.formatDescription)(node.description),
+        });
+    }
+    extractDirectiveLocations(node, errorMessages) {
+        const locations = new Set();
+        const handledLocations = new Set();
+        for (const locationNode of node.locations) {
+            const locationName = locationNode.value;
+            if (handledLocations.has(locationName)) {
+                continue;
+            }
+            if (!string_constants_1.EXECUTABLE_DIRECTIVE_LOCATIONS.has(locationName) && !string_constants_1.TYPE_SYSTEM_DIRECTIVE_LOCATIONS.has(locationName)) {
+                errorMessages.push((0, errors_1.invalidDirectiveDefinitionLocationErrorMessage)(locationName));
+                handledLocations.add(locationName);
+                continue;
+            }
+            if (locations.has(locationName)) {
+                errorMessages.push((0, errors_1.duplicateDirectiveDefinitionLocationErrorMessage)(locationName));
+                handledLocations.add(locationName);
+                continue;
+            }
+            locations.add(locationName);
+        }
+        return locations;
+    }
+    extractArgumentData(argumentNodes, errorMessages) {
+        const argumentTypeNodeByArgumentName = new Map();
+        const optionalArgumentNames = new Set();
+        const requiredArgumentNames = new Set();
+        const output = {
+            argumentTypeNodeByArgumentName,
+            optionalArgumentNames,
+            requiredArgumentNames,
+        };
+        if (!argumentNodes) {
+            return output;
+        }
+        const duplicateArgumentNames = new Set();
+        for (const argumentNode of argumentNodes) {
+            const name = argumentNode.name.value;
+            if (argumentTypeNodeByArgumentName.has(name)) {
+                duplicateArgumentNames.add(name);
+                continue;
+            }
+            if (argumentNode.defaultValue) {
+                optionalArgumentNames.add(name);
+            }
+            if ((0, utils_4.isTypeRequired)(argumentNode.type) && !argumentNode.defaultValue) {
+                requiredArgumentNames.add(name);
+            }
+            argumentTypeNodeByArgumentName.set(name, {
+                name,
+                typeNode: argumentNode.type,
+                defaultValue: argumentNode.defaultValue,
+            });
+        }
+        if (duplicateArgumentNames.size > 0) {
+            errorMessages.push((0, errors_1.duplicateDirectiveDefinitionArgumentErrorMessage)([...duplicateArgumentNames]));
+        }
+        return output;
+    }
+    // returns true if the directive is custom; otherwise, false
+    addDirectiveDefinitionDataByNode(node) {
+        const name = node.name.value;
+        if (this.definedDirectiveNames.has(name)) {
+            this.errors.push((0, errors_1.duplicateDirectiveDefinitionError)(name));
+            return false;
+        }
+        this.definedDirectiveNames.add(name);
+        this.directiveDefinitionByDirectiveName.set(name, node);
+        // Normalize federation directives by replacing them with predefined definitions
+        if (constants_1.V2_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME.has(name)) {
+            this.isSubgraphVersionTwo = true;
+            return false;
+        }
+        if (constants_1.ALL_IN_BUILT_DIRECTIVE_NAMES.has(name)) {
+            return false;
+        }
+        const errorMessages = [];
+        const { argumentTypeNodeByArgumentName, optionalArgumentNames, requiredArgumentNames } = this.extractArgumentData(node.arguments, errorMessages);
+        this.directiveDefinitionDataByDirectiveName.set(name, {
+            argumentTypeNodeByArgumentName,
+            isRepeatable: node.repeatable,
+            locations: this.extractDirectiveLocations(node, errorMessages),
+            name,
+            node,
+            optionalArgumentNames,
+            requiredArgumentNames,
+        });
+        if (errorMessages.length > 0) {
+            this.errors.push((0, errors_1.invalidDirectiveDefinitionError)(name, errorMessages));
+        }
+        return true;
+    }
+    addFieldDataByNode(fieldDataByFieldName, node, argumentDataByArgumentName, directivesByDirectiveName) {
+        const name = node.name.value;
+        const fieldPath = `${this.originalParentTypeName}.${name}`;
+        const isNodeExternalOrShareableResult = (0, utils_4.isNodeExternalOrShareable)(node, !this.isSubgraphVersionTwo, directivesByDirectiveName);
+        const fieldData = {
+            argumentDataByArgumentName: argumentDataByArgumentName,
+            configureDescriptionDataBySubgraphName: new Map(),
+            isExternalBySubgraphName: new Map([
+                [this.subgraphName, isNodeExternalOrShareableResult.isExternal],
+            ]),
+            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isShareableBySubgraphName: new Map([
+                [this.subgraphName, isNodeExternalOrShareableResult.isShareable],
+            ]),
+            kind: graphql_1.Kind.FIELD_DEFINITION,
+            name,
+            namedTypeName: (0, ast_1.getTypeNodeNamedTypeName)(node.type),
+            node: (0, ast_1.getMutableFieldNode)(node, fieldPath, this.errors),
+            originalParentTypeName: this.originalParentTypeName,
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            renamedParentTypeName: this.renamedParentTypeName || this.originalParentTypeName,
+            subgraphNames: new Set([this.subgraphName]),
+            type: (0, ast_1.getMutableTypeNode)(node.type, fieldPath, this.errors),
+            directivesByDirectiveName,
+            description: (0, utils_1.formatDescription)(node.description),
+        };
+        this.extractConfigureDescriptionsData(fieldData);
+        fieldDataByFieldName.set(name, fieldData);
+        return fieldData;
+    }
+    addInputValueDataByNode(inputValueDataByValueName, node, originalPath, renamedPath) {
+        const name = node.name.value;
+        // Only arguments have renamed paths
+        const isArgument = !!renamedPath;
+        if (node.defaultValue && !(0, utils_4.areDefaultValuesCompatible)(node.type, node.defaultValue)) {
+            this.errors.push((0, errors_1.incompatibleInputValueDefaultValueTypeError)((isArgument ? string_constants_1.ARGUMENT : string_constants_1.INPUT_FIELD) + ` "${name}"`, originalPath, (0, merge_1.printTypeNode)(node.type), (0, graphql_1.print)(node.defaultValue)));
+        }
+        const inputValueData = {
+            configureDescriptionDataBySubgraphName: new Map(),
+            directivesByDirectiveName: this.extractDirectives(node, new Map()),
+            includeDefaultValue: !!node.defaultValue,
+            isArgument,
+            kind: isArgument ? graphql_1.Kind.ARGUMENT : graphql_1.Kind.INPUT_VALUE_DEFINITION,
+            name,
+            node: (0, ast_1.getMutableInputValueNode)(node, originalPath, this.errors),
+            originalPath,
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            renamedPath: renamedPath || originalPath,
+            requiredSubgraphNames: new Set((0, utils_4.isTypeRequired)(node.type) ? [this.subgraphName] : []),
+            subgraphNames: new Set([this.subgraphName]),
+            type: (0, ast_1.getMutableTypeNode)(node.type, originalPath, this.errors),
+            defaultValue: node.defaultValue, // TODO validate
+            description: (0, utils_1.formatDescription)(node.description),
+        };
+        this.extractConfigureDescriptionsData(inputValueData);
+        inputValueDataByValueName.set(name, inputValueData);
+    }
     upsertInterfaceDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         const entityInterfaceData = this.entityInterfaceDataByTypeName.get(typeName);
         if (entityInterfaceData && node.fields) {
@@ -383,10 +793,11 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
-            this.updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType);
+            this.updateCompositeOutputDataByNode(node, parentData, extensionType);
             return;
         }
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             fieldDataByFieldName: new Map(),
@@ -399,7 +810,9 @@ class NormalizationFactory {
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     getRenamedRootTypeName(typeName) {
         const operationTypeNode = this.operationTypeNodeByTypeName.get(typeName);
@@ -428,7 +841,7 @@ class NormalizationFactory {
     upsertObjectDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const isRootType = this.isTypeNameRootType(typeName);
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType);
         this.addInterfaceObjectFieldsByNode(node);
@@ -437,13 +850,14 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
-            this.updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType);
+            this.updateCompositeOutputDataByNode(node, parentData, extensionType);
             this.addConcreteTypeNamesForImplementedInterfaces(parentData.implementedInterfaceTypeNames, typeName);
             return;
         }
         const implementedInterfaceTypeNames = this.extractImplementedInterfaceTypeNames(node, new Set());
         this.addConcreteTypeNamesForImplementedInterfaces(implementedInterfaceTypeNames, typeName);
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             fieldDataByFieldName: new Map(),
@@ -458,13 +872,15 @@ class NormalizationFactory {
             renamedTypeName: this.getRenamedRootTypeName(typeName),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     upsertEnumDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectivesAndAuthorization(node, parentData?.directivesByDirectiveName || new Map());
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
@@ -474,10 +890,12 @@ class NormalizationFactory {
             this.setParentDataExtensionType(parentData, extensionType);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            this.extractConfigureDescriptionsData(parentData);
             return;
         }
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
             appearances: 1,
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             enumValueDataByValueName: new Map(),
@@ -487,12 +905,14 @@ class NormalizationFactory {
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     upsertInputObjectByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
@@ -503,9 +923,11 @@ class NormalizationFactory {
             parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            this.extractConfigureDescriptionsData(parentData);
             return;
         }
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             inputValueDataByValueName: new Map(),
@@ -516,13 +938,15 @@ class NormalizationFactory {
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     upsertScalarByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectivesAndAuthorization(node, parentData?.directivesByDirectiveName || new Map());
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
@@ -531,9 +955,11 @@ class NormalizationFactory {
             }
             this.setParentDataExtensionType(parentData, extensionType);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            this.extractConfigureDescriptionsData(parentData);
             return;
         }
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
@@ -541,7 +967,9 @@ class NormalizationFactory {
             node: (0, ast_1.getMutableScalarNode)(node.name),
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     extractUnionMembers(node, membersByMemberTypeName) {
         if (!node.types) {
@@ -571,7 +999,7 @@ class NormalizationFactory {
     upsertUnionByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         // Also adds the concrete type name edges to the internal graph
         this.addConcreteTypeNamesForUnion(node);
@@ -583,9 +1011,11 @@ class NormalizationFactory {
             this.setParentDataExtensionType(parentData, extensionType);
             this.extractUnionMembers(node, parentData.memberByMemberTypeName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            this.extractConfigureDescriptionsData(parentData);
             return;
         }
-        this.parentDefinitionDataByTypeName.set(typeName, {
+        const newParentData = {
+            configureDescriptionDataBySubgraphName: new Map(),
             directivesByDirectiveName,
             extensionType,
             kind: graphql_1.Kind.UNION_TYPE_DEFINITION,
@@ -594,7 +1024,9 @@ class NormalizationFactory {
             node: (0, ast_1.getMutableUnionNode)(node.name),
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
-        });
+        };
+        this.extractConfigureDescriptionsData(newParentData);
+        this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
     extractKeyFieldSets(node, keyFieldSetData) {
         const isUnresolvableByRawKeyFieldSet = keyFieldSetData.isUnresolvableByKeyFieldSet;
@@ -604,13 +1036,12 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.expectedEntityError)(parentTypeName));
             return;
         }
-        const errorMessages = [];
+        // validation happens elsewhere
         for (const directive of node.directives) {
             if (directive.name.value !== string_constants_1.KEY) {
                 continue;
             }
             if (!directive.arguments || directive.arguments.length < 1) {
-                errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.KEY, parentTypeName, [string_constants_1.FIELDS]));
                 continue;
             }
             let keyFieldSet;
@@ -628,7 +1059,6 @@ class NormalizationFactory {
                 }
                 if (arg.value.kind !== graphql_1.Kind.STRING) {
                     keyFieldSet = undefined;
-                    errorMessages.push((0, errors_1.invalidKeyDirectiveArgumentErrorMessage)(arg.value.kind));
                     break;
                 }
                 keyFieldSet = arg.value.value;
@@ -637,9 +1067,6 @@ class NormalizationFactory {
                 isUnresolvableByRawKeyFieldSet.set(keyFieldSet, isUnresolvable);
             }
         }
-        if (errorMessages.length) {
-            this.errors.push((0, errors_1.invalidKeyDirectivesError)(parentTypeName, errorMessages));
-        }
     }
     validateInterfaceImplementations(data) {
         if (data.implementedInterfaceTypeNames.size < 1) {
@@ -745,20 +1172,40 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.invalidInterfaceImplementationError)(data.name, (0, utils_3.kindToTypeString)(data.kind), implementationErrorsMap));
         }
     }
-    handleOverrideDeclaration(node, hostPath, errorMessages) {
-        const argumentNode = node.arguments[0];
-        if (argumentNode.value.kind !== graphql_1.Kind.STRING) {
-            errorMessages.push((0, errors_1.invalidDirectiveArgumentTypeErrorMessage)(true, string_constants_1.FROM, graphql_1.Kind.STRING, argumentNode.value.kind));
+    handleAuthenticatedDirective(data, parentTypeName) {
+        if (data.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION &&
+            data.kind !== graphql_1.Kind.FIELD_DEFINITION &&
+            data.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
             return;
         }
-        const targetSubgraphName = argumentNode.value.value;
+        if (data.kind !== graphql_1.Kind.FIELD_DEFINITION) {
+            this.leafTypeNamesWithAuthorizationDirectives.add(parentTypeName);
+        }
+        const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, parentTypeName, () => (0, utils_3.newAuthorizationData)(parentTypeName));
+        (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, data.node).requiresAuthentication = true;
+    }
+    handleOverrideDirective({ data, directiveCoords, errorMessages, targetSubgraphName }) {
         if (targetSubgraphName === this.subgraphName) {
-            errorMessages.push((0, errors_1.equivalentSourceAndTargetOverrideErrorMessage)(targetSubgraphName, hostPath));
+            errorMessages.push((0, errors_1.equivalentSourceAndTargetOverrideErrorMessage)(targetSubgraphName, directiveCoords));
             return;
         }
         const overrideDataForSubgraph = (0, utils_3.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-        const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.renamedParentTypeName || this.originalParentTypeName, () => new Set());
-        overriddenFieldNamesForParent.add(this.childName);
+        (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName || data.originalParentTypeName, () => new Set()).add(data.name);
+    }
+    handleRequiresScopesDirective({ directiveCoords, orScopes, requiredScopes }) {
+        if (orScopes.length > utils_3.maxOrScopes) {
+            this.invalidOrScopesHostPaths.add(directiveCoords);
+            return;
+        }
+        for (const scopes of orScopes) {
+            const andScopes = new Set();
+            for (const scope of scopes.values) {
+                andScopes.add(scope.value);
+            }
+            if (andScopes.size > 0) {
+                requiredScopes.push(andScopes);
+            }
+        }
     }
     getKafkaPublishConfiguration(directive, argumentDataByArgumentName, errorMessages) {
         const topics = [];
@@ -869,7 +1316,7 @@ class NormalizationFactory {
             switch (argumentNode.name.value) {
                 case string_constants_1.SUBJECTS: {
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
-                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_1.SUBJECTS));
+                        // errorMessages.push(invalidEventSubjectsErrorMessage(SUBJECTS));
                         continue;
                     }
                     for (const value of argumentNode.value.values) {
@@ -939,15 +1386,16 @@ class NormalizationFactory {
                                 break;
                             case string_constants_1.CONSUMER_INACTIVE_THRESHOLD:
                                 if (field.value.kind != graphql_1.Kind.INT) {
-                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)('edfs__NatsStreamConfiguration(consumerInactiveThreshold: ...)', graphql_1.Kind.INT));
+                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(field.value), 'edfs__NatsStreamConfiguration', `consumerInactiveThreshold`, string_constants_1.INT_SCALAR));
                                     isValid = false;
                                     continue;
                                 }
+                                // It should not be possible for this to error
                                 try {
                                     consumerInactiveThreshold = parseInt(field.value.value, 10);
                                 }
                                 catch (e) {
-                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)('edfs__NatsStreamConfiguration(consumerInactiveThreshold: ...)', graphql_1.Kind.INT, field.value.value));
+                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(field.value), 'edfs__NatsStreamConfiguration', `consumerInactiveThreshold`, string_constants_1.INT_SCALAR));
                                     isValid = false;
                                 }
                                 break;
@@ -1250,6 +1698,11 @@ class NormalizationFactory {
             this.parentDefinitionDataByTypeName.delete(string_constants_1.EDFS_NATS_STREAM_CONFIGURATION);
             definitions.push(constants_1.EDFS_NATS_STREAM_CONFIGURATION_DEFINITION);
         }
+        if (this.referencedDirectiveNames.has(string_constants_1.LINK)) {
+            definitions.push(constants_1.LINK_DEFINITION);
+            definitions.push(constants_1.LINK_IMPORT_DEFINITION);
+            definitions.push(constants_1.LINK_PURPOSE_DEFINITION);
+        }
         if (invalidEventsDirectiveDataByRootFieldPath.size > 0) {
             errorMessages.push((0, errors_1.invalidRootTypeFieldEventsDirectivesErrorMessage)(invalidEventsDirectiveDataByRootFieldPath));
         }
@@ -1327,6 +1780,85 @@ class NormalizationFactory {
             this.validateAndAddKeyToConfiguration(parentData, keyFieldSetData);
         }
     }
+    getValidFlattenedDirectiveArray(directivesByDirectiveName, directiveCoords) {
+        const flattenedArray = [];
+        for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
+            const directiveDefinition = this.directiveDefinitionDataByDirectiveName.get(directiveName);
+            if (!directiveDefinition) {
+                continue;
+            }
+            if (!directiveDefinition.isRepeatable && directiveNodes.length > 1) {
+                const handledDirectiveNames = (0, utils_3.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
+                if (!handledDirectiveNames.has(directiveName)) {
+                    handledDirectiveNames.add(directiveName);
+                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, directiveCoords, '1st', [
+                        (0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName),
+                    ]));
+                }
+                continue;
+            }
+            if (directiveName !== string_constants_1.KEY) {
+                flattenedArray.push(...directiveNodes);
+                continue;
+            }
+            const normalizedDirectiveNodes = [];
+            const entityKeys = new Set();
+            for (let i = 0; i < directiveNodes.length; i++) {
+                const keyDirectiveNode = directiveNodes[i];
+                const directiveValue = keyDirectiveNode.arguments[0].value;
+                if (directiveValue.kind !== graphql_1.Kind.STRING) {
+                    continue;
+                }
+                const entityKey = directiveValue.value;
+                if (entityKeys.has(entityKey)) {
+                    continue;
+                }
+                entityKeys.add(entityKey);
+                flattenedArray.push(keyDirectiveNode);
+                normalizedDirectiveNodes.push(keyDirectiveNode);
+            }
+            directivesByDirectiveName.set(directiveName, normalizedDirectiveNodes);
+        }
+        return flattenedArray;
+    }
+    getEnumNodeByData(enumDefinitionData) {
+        enumDefinitionData.node.description = enumDefinitionData.description;
+        enumDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(enumDefinitionData.directivesByDirectiveName, enumDefinitionData.name);
+        enumDefinitionData.node.values = (0, utils_4.childMapToValueArray)(enumDefinitionData.enumValueDataByValueName, this.authorizationDataByParentTypeName);
+        return enumDefinitionData.node;
+    }
+    getInputObjectNodeByData(inputObjectDefinitionData) {
+        inputObjectDefinitionData.node.description = inputObjectDefinitionData.description;
+        inputObjectDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(inputObjectDefinitionData.directivesByDirectiveName, inputObjectDefinitionData.name);
+        inputObjectDefinitionData.node.fields = (0, utils_4.childMapToValueArray)(inputObjectDefinitionData.inputValueDataByValueName, this.authorizationDataByParentTypeName);
+        return inputObjectDefinitionData.node;
+    }
+    getCompositeOutputNodeByData(compositeOutputData) {
+        compositeOutputData.node.description = compositeOutputData.description;
+        compositeOutputData.node.directives = this.getValidFlattenedDirectiveArray(compositeOutputData.directivesByDirectiveName, compositeOutputData.name);
+        compositeOutputData.node.fields = (0, utils_4.childMapToValueArray)(compositeOutputData.fieldDataByFieldName, this.authorizationDataByParentTypeName);
+        compositeOutputData.node.interfaces = (0, utils_1.setToNamedTypeNodeArray)(compositeOutputData.implementedInterfaceTypeNames);
+        return compositeOutputData.node;
+    }
+    getScalarNodeByData(scalarDefinitionData) {
+        scalarDefinitionData.node.description = scalarDefinitionData.description;
+        scalarDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByDirectiveName, scalarDefinitionData.name);
+        return scalarDefinitionData.node;
+    }
+    getSchemaNodeByData(schemaData) {
+        return {
+            description: schemaData.description,
+            directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByDirectiveName, schemaData.name),
+            kind: schemaData.kind,
+            operationTypes: (0, utils_3.mapToArrayOfValues)(schemaData.operationTypes),
+        };
+    }
+    getUnionNodeByData(unionDefinitionData) {
+        unionDefinitionData.node.description = unionDefinitionData.description;
+        unionDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(unionDefinitionData.directivesByDirectiveName, unionDefinitionData.name);
+        unionDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(unionDefinitionData.memberByMemberTypeName);
+        return unionDefinitionData.node;
+    }
     normalize(document) {
         /* factory.allDirectiveDefinitions is initialized with v1 directive definitions, and v2 definitions are only added
         after the visitor has visited the entire schema and the subgraph is known to be a V2 graph. Consequently,
@@ -1334,6 +1866,10 @@ class NormalizationFactory {
         // Collect any renamed root types
         (0, walkers_1.upsertDirectiveSchemaAndEntityDefinitions)(this, document);
         (0, walkers_1.upsertParentsAndChildren)(this, document);
+        this.validateDirectives(this.schemaData, string_constants_1.SCHEMA);
+        for (const [parentTypeName, parentData] of this.parentDefinitionDataByTypeName) {
+            this.validateDirectives(parentData, parentTypeName);
+        }
         (0, walkers_1.consolidateAuthorizationDirectives)(this, document);
         for (const interfaceTypeName of this.interfaceTypeNamesWithAuthorizationDirectives) {
             const interfaceAuthorizationData = this.authorizationDataByParentTypeName.get(interfaceTypeName);
@@ -1388,17 +1924,31 @@ class NormalizationFactory {
         }
         // subscriptionFilter is temporarily valid only in an EDG
         if (this.edfsDirectiveReferences.size > 0 && this.referencedDirectiveNames.has(string_constants_1.SUBSCRIPTION_FILTER)) {
-            this.directiveDefinitionByDirectiveName.set(string_constants_1.SUBSCRIPTION_FILTER, constants_1.SUBSCRIPTION_FILTER_DEFINITION);
             definitions.push(constants_1.SUBSCRIPTION_FILTER_DEFINITION);
             definitions.push(constants_1.SUBSCRIPTION_FILTER_CONDITION_DEFINITION);
             definitions.push(constants_1.SUBSCRIPTION_FIELD_CONDITION_DEFINITION);
             definitions.push(constants_1.SUBSCRIPTION_FILTER_VALUE_DEFINITION);
         }
+        if (this.referencedDirectiveNames.has(string_constants_1.CONFIGURE_DESCRIPTION)) {
+            definitions.push(constants_1.CONFIGURE_DESCRIPTION_DEFINITION);
+        }
+        if (this.referencedDirectiveNames.has(string_constants_1.CONFIGURE_CHILD_DESCRIPTIONS)) {
+            definitions.push(constants_1.CONFIGURE_CHILD_DESCRIPTIONS_DEFINITION);
+        }
         for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
             definitions.push(directiveDefinition);
         }
-        if (this.schemaDefinition.operationTypes.size > 0) {
-            definitions.push((0, utils_4.getSchemaNodeByData)(this.schemaDefinition, this.errors, this.directiveDefinitionByDirectiveName));
+        if (this.schemaData.operationTypes.size > 0) {
+            definitions.push(this.getSchemaNodeByData(this.schemaData));
+        }
+        /*
+         * Sometimes an @openfed__configureDescription directive is defined before a description is, e.g., on an extension.
+         * If at this stage there is still no description, it is propagated as an error.
+         * */
+        for (const data of this.invalidConfigureDescriptionNodeDatas) {
+            if (!data.description) {
+                this.errors.push((0, errors_1.configureDescriptionNoDescriptionError)((0, utils_3.kindToTypeString)(data.kind), data.name));
+            }
         }
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
             switch (parentDefinitionData.kind) {
@@ -1407,14 +1957,15 @@ class NormalizationFactory {
                         this.errors.push((0, errors_1.noDefinedEnumValuesError)(parentTypeName));
                         break;
                     }
-                    definitions.push((0, utils_4.getEnumNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
+                    (0, utils_4.removeIgnoredDirectives)(parentDefinitionData);
+                    definitions.push(this.getEnumNodeByData(parentDefinitionData));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
                     if (parentDefinitionData.inputValueDataByValueName.size < 1) {
                         this.errors.push((0, errors_1.noInputValueDefinitionsError)(parentTypeName));
                         break;
                     }
-                    definitions.push((0, utils_4.getInputObjectNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
+                    definitions.push(this.getInputObjectNodeByData(parentDefinitionData));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
@@ -1426,6 +1977,8 @@ class NormalizationFactory {
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                     }
+                    (0, utils_4.removeIgnoredDirectives)(parentDefinitionData);
+                    (0, utils_4.removeInheritableDirectivesFromObjectParent)(parentDefinitionData);
                     if (this.parentsWithChildArguments.has(parentTypeName) || !isObject) {
                         const externalInterfaceFieldNames = [];
                         for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByFieldName) {
@@ -1464,7 +2017,7 @@ class NormalizationFactory {
                     this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
                     (0, utils_2.addFieldNamesToConfigurationData)(parentDefinitionData.fieldDataByFieldName, configurationData);
                     this.validateInterfaceImplementations(parentDefinitionData);
-                    definitions.push((0, utils_4.getCompositeOutputNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
+                    definitions.push(this.getCompositeOutputNodeByData(parentDefinitionData));
                     // interfaces and objects must define at least one field
                     if (parentDefinitionData.fieldDataByFieldName.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
                         this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
@@ -1475,10 +2028,11 @@ class NormalizationFactory {
                         this.errors.push((0, errors_1.noBaseScalarDefinitionError)(parentTypeName));
                         break;
                     }
-                    definitions.push((0, utils_4.getScalarNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName));
+                    (0, utils_4.removeIgnoredDirectives)(parentDefinitionData);
+                    definitions.push(this.getScalarNodeByData(parentDefinitionData));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    definitions.push((0, utils_4.getUnionNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName));
+                    definitions.push(this.getUnionNodeByData(parentDefinitionData));
                     this.validateUnionMembers(parentDefinitionData);
                     break;
                 default:
@@ -1487,7 +2041,7 @@ class NormalizationFactory {
         }
         // Check that explicitly defined operations types are valid objects and that their fields are also valid
         for (const operationType of Object.values(graphql_1.OperationTypeNode)) {
-            const operationTypeNode = this.schemaDefinition.operationTypes.get(operationType);
+            const operationTypeNode = this.schemaData.operationTypes.get(operationType);
             const defaultTypeName = (0, utils_3.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType, string_constants_1.OPERATION_TO_DEFAULT);
             // If an operation type name was not declared, use the default
             const operationTypeName = operationTypeNode ? (0, ast_1.getTypeNodeNamedTypeName)(operationTypeNode.type) : defaultTypeName;
@@ -1562,7 +2116,7 @@ class NormalizationFactory {
             if (executableLocations.size < 1) {
                 continue;
             }
-            (0, utils_4.addPersistedDirectiveDefinitionDataByNode)(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, executableLocations, this.subgraphName);
+            this.addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, executableLocations);
         }
         this.isSubgraphEventDrivenGraph = this.edfsDirectiveReferences.size > 0;
         if (this.isSubgraphEventDrivenGraph) {