@wundergraph/composition 0.57.0 → 0.58.1

package/dist/v1/normalization/normalization-factory.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NormalizationFactory = void 0;
 exports.normalizeSubgraphFromString = normalizeSubgraphFromString;
 exports.normalizeSubgraph = normalizeSubgraph;
-exports.batchNormalize = batchNormalize;
 const graphql_1 = require("graphql");
 const utils_1 = require("../../ast/utils");
 const utils_2 = require("./utils");
@@ -13,10 +12,9 @@ const errors_1 = require("../../errors/errors");
 const strings_1 = require("../constants/strings");
 const buildASTSchema_1 = require("../../buildASTSchema/buildASTSchema");
 const merge_1 = require("@graphql-tools/merge");
-const subgraph_1 = require("../subgraph/subgraph");
 const warnings_1 = require("../warnings/warnings");
 const walkers_1 = require("./walkers");
-const types_1 = require("../../schema-building/types");
+const types_1 = require("../../schema-building/types/types");
 const utils_4 = require("../../schema-building/utils");
 const ast_1 = require("../../schema-building/ast");
 const graph_1 = require("../../resolvability-graph/graph");
@@ -26,6 +24,8 @@ const integer_constants_1 = require("../../utils/integer-constants");
 const utils_5 = require("../../utils/utils");
 const utils_6 = require("../../router-configuration/utils");
 const non_directive_definitions_1 = require("../constants/non-directive-definitions");
+const validation_1 = require("../../validation/validation");
+const utils_7 = require("../../directive-definition-data/utils");
 function normalizeSubgraphFromString({ noLocation, options, sdlString, }) {
     const { error, documentNode } = (0, utils_1.safeParse)(sdlString, noLocation);
     if (error || !documentNode) {
@@ -64,7 +64,9 @@ class NormalizationFactory {
     entityDataByTypeName = new Map();
     entityInterfaceDataByTypeName = new Map();
     eventsConfigurations = new Map();
+    federatedDirectiveDataByName = new Map();
     fieldSetDataByTypeName = new Map();
+    importDataByDirectiveName = new Map();
     interfaceImplementationTypeNamesByInterfaceTypeName = new Map();
     internalGraph;
     invalidConfigureDescriptionNodeDatas = [];
@@ -85,12 +87,12 @@ class NormalizationFactory {
     operationTypeNodeByTypeName = new Map();
     originalParentTypeName = '';
     originalTypeNameByRenamedTypeName = new Map();
-    overridesByTargetSubgraphName = new Map();
+    overriddenFieldNamesByTypeNameByTargetSubgraphName = new Map();
     parentDefinitionDataByTypeName = new Map();
-    schemaData;
     referencedDirectiveNames = new Set();
     referencedTypeNames = new Set();
     renamedParentTypeName = '';
+    schemaData;
     subgraphName;
     unvalidatedExternalFieldCoords = new Set();
     usesEdfsNatsStreamConfiguration = false;
@@ -107,27 +109,6 @@ class NormalizationFactory {
             operationTypes: new Map(),
         };
     }
-    sanitizeDefaultValue({ data, namedTypeData, node }) {
-        if (!data.defaultValue) {
-            return;
-        }
-        if (!(0, utils_4.isEnumData)(namedTypeData)) {
-            return;
-        }
-        data.defaultValue = (0, graphql_1.visit)(data.defaultValue, {
-            StringValue: {
-                enter(node) {
-                    return {
-                        kind: graphql_1.Kind.ENUM,
-                        value: node.value,
-                    };
-                },
-            },
-        });
-        if (node) {
-            node.defaultValue = data.defaultValue;
-        }
-    }
     validateArguments(fieldData, parentKind) {
         for (const argumentData of fieldData.argumentDataByName.values()) {
             const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(argumentData.type);
@@ -142,7 +123,7 @@ class NormalizationFactory {
             }
             if ((0, utils_4.isInputNodeKind)(namedTypeData.kind)) {
                 argumentData.namedTypeKind = namedTypeData.kind;
-                this.sanitizeDefaultValue({ data: argumentData, namedTypeData, node: argumentData.node });
+                (0, utils_4.sanitizeDefaultValue)({ data: argumentData, namedTypeData, node: argumentData.node });
                 continue;
             }
             this.errors.push((0, errors_1.invalidNamedTypeError)({
@@ -155,89 +136,6 @@ class NormalizationFactory {
     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 && argumentValue.kind !== graphql_1.Kind.STRING) {
-                                return false;
-                            }
-                            const enumValue = parentData.enumValueDataByName.get(argumentValue.value);
-                            if (!enumValue) {
-                                return false;
-                            }
-                            return !enumValue.directivesByName.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);
-            }
-        }
-    }
     handleFieldInheritableDirectives({ directivesByName, fieldName, inheritedDirectiveNames, parentData, }) {
         if (this.doesParentRequireFetchReasons && !directivesByName.has(string_constants_1.REQUIRE_FETCH_REASONS)) {
             directivesByName.set(string_constants_1.REQUIRE_FETCH_REASONS, [(0, utils_5.generateSimpleDirective)(string_constants_1.REQUIRE_FETCH_REASONS)]);
@@ -269,8 +167,8 @@ class NormalizationFactory {
         const isObjectKind = (0, utils_3.isObjectNodeKind)(node.kind);
         for (const directiveNode of node.directives) {
             const directiveName = directiveNode.name.value;
-            // Don't create pointless repetitions of @shareable
             if (directiveName === string_constants_1.SHAREABLE) {
+                // @shareable need only be propagated once
                 (0, utils_5.getValueOrDefault)(directivesByName, directiveName, () => [directiveNode]);
             }
             else {
@@ -305,7 +203,10 @@ class NormalizationFactory {
             if (isAuthenticated) {
                 this.handleAuthenticatedDirective(data, parentTypeName);
             }
-            if (isSemanticNonNull && isField) {
+            if (!isField) {
+                return errorMessages;
+            }
+            if (isSemanticNonNull) {
                 // The default argument for levels is [0], so a non-null wrapper is invalid.
                 if ((0, utils_4.isTypeRequired)(data.type)) {
                     errorMessages.push((0, errors_1.semanticNonNullLevelsNonNullErrorMessage)({
@@ -317,9 +218,12 @@ class NormalizationFactory {
                     data.nullLevelsBySubgraphName.set(this.subgraphName, new Set([0]));
                 }
             }
-            if (isListSize && isField && !(0, utils_4.isTypeNodeListType)(data.type)) {
+            if (isListSize && !(0, utils_4.isTypeNodeListType)(data.type)) {
                 errorMessages.push((0, errors_1.listSizeFieldMustReturnListOrUseSizedFieldsErrorMessage)(directiveCoords, (0, merge_1.printTypeNode)(data.type)));
             }
+            if (!isCost && !isListSize) {
+                this.recordDirectiveWeightOnField({ data: data, definitionData, directiveName, directiveNode });
+            }
             return errorMessages;
         }
         const definedArgumentNames = new Set();
@@ -333,13 +237,17 @@ class NormalizationFactory {
                 continue;
             }
             definedArgumentNames.add(argumentName);
-            const argumentData = definitionData.argumentTypeNodeByName.get(argumentName);
+            const argumentData = definitionData.argumentDataByName.get(argumentName);
             if (!argumentData) {
                 unexpectedArgumentNames.add(argumentName);
                 continue;
             }
-            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)));
+            if (!(0, validation_1.isArgumentValueValid)({
+                argumentValue: argumentNode.value,
+                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                typeNode: argumentData.type,
+            })) {
+                errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(argumentNode.value), `@${directiveName}`, argumentName, (0, merge_1.printTypeNode)(argumentData.type)));
                 continue;
             }
             /* Individual directives are handled in the loop because they validate a single argument, and duplicate
@@ -376,8 +284,13 @@ class NormalizationFactory {
         if (isCost) {
             this.handleCostDirective({ data, directiveCoords, directiveNode, errorMessages });
         }
-        else if (isListSize && isField) {
-            this.handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages });
+        else if (isField) {
+            if (isListSize) {
+                this.handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages });
+            }
+            else {
+                this.recordDirectiveWeightOnField({ data: data, definitionData, directiveName, directiveNode });
+            }
         }
         if (duplicateArgumentNames.size > 0) {
             errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionsErrorMessage)([...duplicateArgumentNames]));
@@ -404,6 +317,49 @@ class NormalizationFactory {
         }
         return errorMessages;
     }
+    handleComposeDirective(node) {
+        const argNode = node.arguments[0];
+        if (!argNode) {
+            return;
+        }
+        const rawValue = argNode.value.value;
+        if (!rawValue.startsWith(string_constants_1.LITERAL_AT)) {
+            this.errors.push((0, errors_1.noLeadingAtComposeDirectiveNameError)(rawValue));
+            return;
+        }
+        const directiveName = rawValue.substring(1);
+        if (constants_1.DIRECTIVE_DEFINITION_BY_NAME.has(directiveName)) {
+            if (directiveName === string_constants_1.ONE_OF) {
+                this.warnings.push((0, warnings_1.composedOneOfDirectiveWarning)(this.subgraphName));
+            }
+            else {
+                this.errors.push((0, errors_1.invalidComposeDirectiveNameError)(rawValue));
+                return;
+            }
+        }
+        const definitionData = this.directiveDefinitionDataByName.get(directiveName);
+        if (!definitionData) {
+            this.errors.push((0, errors_1.unknownComposeDirectiveNameError)(rawValue));
+            return;
+        }
+        const importData = this.importDataByDirectiveName.get(rawValue);
+        if (!importData) {
+            this.errors.push((0, errors_1.unimportedComposeDirectiveNameError)(rawValue));
+            return;
+        }
+        definitionData.majorVersion = importData.majorVersion;
+        definitionData.minorVersion = importData.minorVersion;
+        definitionData.isComposed = true;
+        this.federatedDirectiveDataByName.set(directiveName, definitionData);
+    }
+    handleExecutableDirectives() {
+        for (const [directiveName, definitionData] of this.directiveDefinitionDataByName) {
+            if (definitionData.isComposed || definitionData.executableLocations.size < 1) {
+                continue;
+            }
+            this.federatedDirectiveDataByName.set(directiveName, definitionData);
+        }
+    }
     validateDirectives(data, directiveCoords) {
         const undefinedDirectiveNames = new Set();
         for (const [directiveName, directiveNodes] of data.directivesByName) {
@@ -415,6 +371,9 @@ class NormalizationFactory {
                 }
                 continue;
             }
+            if (definitionData.isComposed) {
+                definitionData.isReferenced = true;
+            }
             const definitionErrorMessages = [];
             const directiveLocation = (0, utils_1.nodeKindToDirectiveLocation)(data.kind);
             if (!definitionData.locations.has(directiveLocation)) {
@@ -432,21 +391,22 @@ class NormalizationFactory {
                 if (!argumentNode.defaultValue) {
                     continue;
                 }
-                const argumentData = definitionData.argumentTypeNodeByName.get(argumentNode.name.value);
+                const argumentData = definitionData.argumentDataByName.get(argumentNode.name.value);
                 if (!argumentData) {
                     continue;
                 }
-                const namedTypeData = this.parentDefinitionDataByTypeName.get((0, ast_1.getTypeNodeNamedTypeName)(argumentData.typeNode));
+                const namedTypeData = this.parentDefinitionDataByTypeName.get((0, ast_1.getTypeNodeNamedTypeName)(argumentData.type));
                 // Undefined types are handled elsewhere
                 if (!namedTypeData) {
                     continue;
                 }
-                this.sanitizeDefaultValue({ data: argumentData, namedTypeData, node: argumentNode });
+                (0, utils_4.sanitizeDefaultValue)({ data: argumentData, namedTypeData, node: argumentNode });
             }
             for (let i = 0; i < directiveNodes.length; i++) {
+                const directiveNode = directiveNodes[i];
                 const errorMessages = this.validateDirective({
                     data,
-                    directiveNode: directiveNodes[i],
+                    directiveNode,
                     definitionData,
                     directiveCoords,
                     errorMessages: i < 1 ? definitionErrorMessages : [],
@@ -544,14 +504,14 @@ class NormalizationFactory {
         for (const argument of directiveNode.arguments) {
             switch (argument.name.value) {
                 case string_constants_1.PROPAGATE: {
-                    if (argument.value.kind != graphql_1.Kind.BOOLEAN) {
+                    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) {
+                    if (argument.value.kind !== graphql_1.Kind.STRING) {
                         return;
                     }
                     configureDescriptionData.description = argument.value.value;
@@ -638,55 +598,12 @@ class NormalizationFactory {
         }
         return argumentDataByName;
     }
-    addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName, node, executableLocations) {
-        const name = node.name.value;
-        const directiveName = `@${name}`;
+    extractDirectiveArgumentData({ argumentNodes, directiveName, errorMessages, }) {
         const argumentDataByName = new Map();
-        for (const argumentNode of node.arguments || []) {
-            this.addInputValueDataByNode({
-                inputValueDataByName: argumentDataByName,
-                isArgument: true,
-                node: argumentNode,
-                originalParentTypeName: directiveName,
-            });
-        }
-        persistedDirectiveDefinitionDataByDirectiveName.set(name, {
-            argumentDataByName: argumentDataByName,
-            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) && !strings_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 argumentTypeNodeByName = new Map();
         const optionalArgumentNames = new Set();
         const requiredArgumentNames = new Set();
         const output = {
-            argumentTypeNodeByName,
+            argumentDataByName,
             optionalArgumentNames,
             requiredArgumentNames,
         };
@@ -694,23 +611,13 @@ class NormalizationFactory {
             return output;
         }
         const duplicateArgumentNames = new Set();
-        for (const argumentNode of argumentNodes) {
-            const name = argumentNode.name.value;
-            if (argumentTypeNodeByName.has(name)) {
+        for (const node of argumentNodes) {
+            const name = node.name.value;
+            if (argumentDataByName.has(name)) {
                 duplicateArgumentNames.add(name);
                 continue;
             }
-            if (argumentNode.defaultValue) {
-                optionalArgumentNames.add(name);
-            }
-            if ((0, utils_4.isTypeRequired)(argumentNode.type) && !argumentNode.defaultValue) {
-                requiredArgumentNames.add(name);
-            }
-            argumentTypeNodeByName.set(name, {
-                name,
-                typeNode: argumentNode.type,
-                defaultValue: argumentNode.defaultValue,
-            });
+            argumentDataByName.set(name, this.addDirectiveArgumentDataByNode({ directiveName, node, optionalArgumentNames, requiredArgumentNames }));
         }
         if (duplicateArgumentNames.size > 0) {
             errorMessages.push((0, errors_1.duplicateDirectiveDefinitionArgumentErrorMessage)([...duplicateArgumentNames]));
@@ -748,6 +655,35 @@ class NormalizationFactory {
             }
         }
     }
+    addDirectiveArgumentDataByNode({ directiveName, node, optionalArgumentNames, requiredArgumentNames, }) {
+        const name = node.name.value;
+        const parentName = `@${directiveName}`;
+        if (node.defaultValue && !(0, utils_4.areDefaultValuesCompatible)(node.type, node.defaultValue)) {
+            this.errors.push((0, errors_1.incompatibleInputValueDefaultValueTypeError)(`argument "${name}"`, parentName, (0, merge_1.printTypeNode)(node.type), (0, graphql_1.print)(node.defaultValue)));
+        }
+        const isRequired = (0, utils_4.isTypeRequired)(node.type);
+        if (node.defaultValue) {
+            optionalArgumentNames.add(name);
+        }
+        else if (isRequired) {
+            requiredArgumentNames.add(name);
+        }
+        const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(node.type);
+        const argumentData = (0, utils_7.newDirectiveArgumentData)({
+            name,
+            directive: `@${directiveName}`,
+            directivesByName: this.extractDirectives(node, new Map()),
+            defaultValue: node.defaultValue,
+            description: (0, utils_1.formatDescription)(node.description),
+            namedTypeKind: constants_1.BASE_SCALARS.has(namedTypeName) ? graphql_1.Kind.SCALAR_TYPE_DEFINITION : graphql_1.Kind.NULL,
+            node: (0, ast_1.getMutableInputValueNode)(node, parentName, this.errors),
+            requiredSubgraphNames: new Set(isRequired ? [this.subgraphName] : []),
+            subgraphNames: new Set([this.subgraphName]),
+            typeNode: (0, ast_1.getMutableTypeNode)(node.type, parentName, this.errors),
+        });
+        this.extractConfigureDescriptionsData(argumentData);
+        return argumentData;
+    }
     // returns true if the directive is custom; otherwise, false
     addDirectiveDefinitionDataByNode(node) {
         const name = node.name.value;
@@ -771,30 +707,42 @@ class NormalizationFactory {
             return false;
         }
         this.directiveDefinitionByName.set(name, node);
+        // @TODO
         const errorMessages = [];
-        const { argumentTypeNodeByName, optionalArgumentNames, requiredArgumentNames } = this.extractArgumentData(node.arguments, errorMessages);
-        this.directiveDefinitionDataByName.set(name, {
-            argumentTypeNodeByName: argumentTypeNodeByName,
+        const { argumentDataByName, optionalArgumentNames, requiredArgumentNames } = this.extractDirectiveArgumentData({
+            argumentNodes: node.arguments,
+            directiveName: name,
+            errorMessages,
+        });
+        const { errors, locations } = (0, ast_1.extractDirectiveLocations)(node);
+        // @TODO
+        if (errors.length > 0) {
+            this.errors.push(...errors);
+        }
+        this.directiveDefinitionDataByName.set(name, (0, utils_7.newDirectiveDefinitionData)({
+            argumentDataByName: argumentDataByName,
+            description: node.description,
             isRepeatable: node.repeatable,
-            locations: this.extractDirectiveLocations(node, errorMessages),
+            locations,
             name,
             node,
             optionalArgumentNames,
             requiredArgumentNames,
-        });
+            subgraphNames: new Set([this.subgraphName]),
+        }));
         if (errorMessages.length > 0) {
             this.errors.push((0, errors_1.invalidDirectiveDefinitionError)(name, errorMessages));
         }
         return true;
     }
-    addFieldDataByNode(fieldDataByFieldName, node, argumentDataByArgumentName, directivesByName, inheritedDirectiveNames = new Set()) {
+    addFieldDataByNode(fieldDataByName, node, argumentDataByName, directivesByName, inheritedDirectiveNames = new Set()) {
         const name = node.name.value;
         const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
         const fieldCoords = `${this.originalParentTypeName}.${name}`;
         const { isExternal, isShareable } = (0, utils_4.isNodeExternalOrShareable)(node, !this.isSubgraphVersionTwo, directivesByName);
         const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(node.type);
         const fieldData = {
-            argumentDataByName: argumentDataByArgumentName,
+            argumentDataByName: argumentDataByName,
             configureDescriptionDataBySubgraphName: new Map(),
             externalFieldDataBySubgraphName: new Map([
                 [this.subgraphName, (0, utils_4.newExternalFieldData)(isExternal)],
@@ -810,7 +758,7 @@ class NormalizationFactory {
             node: (0, ast_1.getMutableFieldNode)(node, fieldCoords, this.errors),
             nullLevelsBySubgraphName: new Map(),
             originalParentTypeName: this.originalParentTypeName,
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             renamedParentTypeName: parentTypeName,
             subgraphNames: new Set([this.subgraphName]),
             type: (0, ast_1.getMutableTypeNode)(node.type, fieldCoords, this.errors),
@@ -821,7 +769,7 @@ class NormalizationFactory {
             this.referencedTypeNames.add(fieldData.namedTypeName);
         }
         this.extractConfigureDescriptionsData(fieldData);
-        fieldDataByFieldName.set(name, fieldData);
+        fieldDataByName.set(name, fieldData);
         return fieldData;
     }
     addInputValueDataByNode({ fieldName, inputValueDataByName, isArgument, node, originalParentTypeName, renamedParentTypeName, }) {
@@ -852,7 +800,7 @@ class NormalizationFactory {
             node: (0, ast_1.getMutableInputValueNode)(node, originalParentTypeName, this.errors),
             originalCoords,
             originalParentTypeName: originalParentTypeName,
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             renamedParentTypeName: federatedParentTypeName,
             requiredSubgraphNames: new Set((0, utils_4.isTypeRequired)(node.type) ? [this.subgraphName] : []),
             subgraphNames: new Set([this.subgraphName]),
@@ -893,7 +841,7 @@ class NormalizationFactory {
             kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInterfaceNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             requireFetchReasonsFieldNames: new Set(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
@@ -959,7 +907,7 @@ class NormalizationFactory {
             kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableObjectNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             requireFetchReasonsFieldNames: new Set(),
             renamedTypeName: this.getRenamedRootTypeName(typeName),
             subgraphNames: new Set([this.subgraphName]),
@@ -996,7 +944,7 @@ class NormalizationFactory {
             kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableEnumNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
         };
@@ -1010,6 +958,7 @@ class NormalizationFactory {
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                // TODO
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToNodeType)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return {
                     success: false,
@@ -1034,7 +983,7 @@ class NormalizationFactory {
             kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInputObjectNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
         };
@@ -1069,7 +1018,7 @@ class NormalizationFactory {
             kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableScalarNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
         };
@@ -1128,7 +1077,7 @@ class NormalizationFactory {
             memberByMemberTypeName: this.extractUnionMembers(node, new Map()),
             name: typeName,
             node: (0, ast_1.getMutableUnionNode)(node.name),
-            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            federatedDirectivesData: (0, utils_4.newFederatedDirectivesData)(),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
         };
@@ -1674,7 +1623,7 @@ class NormalizationFactory {
             errorMessages.push((0, errors_1.equivalentSourceAndTargetOverrideErrorMessage)(targetSubgraphName, directiveCoords));
             return;
         }
-        const overrideDataForSubgraph = (0, utils_5.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
+        const overrideDataForSubgraph = (0, utils_5.getValueOrDefault)(this.overriddenFieldNamesByTypeNameByTargetSubgraphName, targetSubgraphName, () => new Map());
         (0, utils_5.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName, () => new Set()).add(data.name);
     }
     handleSemanticNonNullDirective({ data, directiveNode, errorMessages }) {
@@ -1733,6 +1682,15 @@ class NormalizationFactory {
         }
         data.nullLevelsBySubgraphName.set(this.subgraphName, levels);
     }
+    getOrCreateFieldWeight(typeName, fieldName) {
+        const fieldCoords = `${typeName}.${fieldName}`;
+        return (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
+            typeName,
+            fieldName,
+            argumentWeights: new Map(),
+            directiveArgumentWeights: new Map(),
+        }));
+    }
     handleCostDirective({ data, directiveCoords, directiveNode, errorMessages }) {
         const weightArg = directiveNode.arguments?.find((arg) => arg.name.value === string_constants_1.WEIGHT);
         if (!weightArg || weightArg.value.kind !== graphql_1.Kind.INT) {
@@ -1756,12 +1714,7 @@ class NormalizationFactory {
                     errorMessages.push((0, errors_1.costOnInterfaceFieldErrorMessage)(directiveCoords));
                     break;
                 }
-                const fieldCoords = `${typeName}.${data.name}`;
-                const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
-                    typeName,
-                    fieldName: data.name,
-                    argumentWeights: new Map(),
-                }));
+                const fieldWeight = this.getOrCreateFieldWeight(typeName, data.name);
                 fieldWeight.weight = weightValue;
                 break;
             }
@@ -1779,28 +1732,61 @@ class NormalizationFactory {
                         errorMessages.push((0, errors_1.costOnInterfaceFieldErrorMessage)(directiveCoords));
                         break;
                     }
-                    const parentFieldCoords = `${typeName}.${ivData.fieldName}`;
-                    const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, parentFieldCoords, () => ({
-                        typeName,
-                        fieldName: ivData.fieldName,
-                        argumentWeights: new Map(),
-                    }));
+                    const fieldWeight = this.getOrCreateFieldWeight(typeName, ivData.fieldName);
                     fieldWeight.argumentWeights.set(ivData.name, weightValue);
                 }
                 else {
                     const typeName = ivData.renamedParentTypeName || ivData.originalParentTypeName;
-                    const fieldCoords = `${typeName}.${ivData.name}`;
-                    const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
-                        typeName,
-                        fieldName: ivData.name,
-                        argumentWeights: new Map(),
-                    }));
+                    const fieldWeight = this.getOrCreateFieldWeight(typeName, ivData.name);
                     fieldWeight.weight = weightValue;
                 }
                 break;
             }
         }
     }
+    recordDirectiveWeightOnField({ data, definitionData, directiveName, directiveNode, }) {
+        // This method walks every argument defined on the directive and records a directive weight
+        // on the field only when all these conditions hold:
+        // 1. The argument of the directive has a cost weight assigned
+        // 2. The argument is non-null
+        // 3. The parent type is not an interface type.
+        const typeName = data.renamedParentTypeName || data.originalParentTypeName;
+        const parentTypeData = this.parentDefinitionDataByTypeName.get(typeName);
+        // Directive argument weights should only be recorded for concrete type fields.
+        if (!parentTypeData || parentTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+            return;
+        }
+        // Determine which arguments are non-null on this directive usage.
+        // Record the DirectiveArgument coords if its argument has an explicit non-null value or
+        // if it has a default value and was not explicitly set to null.
+        const suppliedArgNodeByName = new Map();
+        for (const arg of directiveNode.arguments ?? []) {
+            suppliedArgNodeByName.set(arg.name.value, arg.value);
+        }
+        for (const [argName, argData] of definitionData.argumentDataByName) {
+            const coords = `${directiveName}.${argName}`;
+            const argWeight = this.costs.directiveArgumentWeights.get(coords);
+            // Bail if the argName argument does not have cost attached to it.
+            if (argWeight === undefined) {
+                continue;
+            }
+            // Check if this argument is non-null at the usage site:
+            const argNode = suppliedArgNodeByName.get(argName);
+            if (argNode) {
+                if (argNode.kind === graphql_1.Kind.NULL) {
+                    continue;
+                }
+            }
+            else if (!argData.defaultValue || argData.defaultValue.kind === graphql_1.Kind.NULL) {
+                continue;
+            }
+            const fieldWeight = this.getOrCreateFieldWeight(typeName, data.name);
+            // Accumulate across directive usages so that repeatable directives on the same
+            // field are charged once per usage.
+            const existingWeight = fieldWeight.directiveArgumentWeights.get(coords) ?? 0;
+            fieldWeight.directiveArgumentWeights.set(coords, existingWeight + argWeight);
+        }
+    }
     handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages }) {
         const args = directiveNode.arguments;
         if (!args) {
@@ -2102,7 +2088,7 @@ class NormalizationFactory {
                         }
                         switch (fieldName) {
                             case string_constants_1.CONSUMER_NAME:
-                                if (field.value.kind != graphql_1.Kind.STRING || field.value.value.length < 1) {
+                                if (field.value.kind !== graphql_1.Kind.STRING || field.value.value.length < 1) {
                                     invalidRequiredFieldNames.add(fieldName);
                                     isValid = false;
                                     continue;
@@ -2110,7 +2096,7 @@ class NormalizationFactory {
                                 consumerName = field.value.value;
                                 break;
                             case string_constants_1.STREAM_NAME:
-                                if (field.value.kind != graphql_1.Kind.STRING || field.value.value.length < 1) {
+                                if (field.value.kind !== graphql_1.Kind.STRING || field.value.value.length < 1) {
                                     invalidRequiredFieldNames.add(fieldName);
                                     isValid = false;
                                     continue;
@@ -2118,7 +2104,7 @@ class NormalizationFactory {
                                 streamName = field.value.value;
                                 break;
                             case string_constants_1.CONSUMER_INACTIVE_THRESHOLD:
-                                if (field.value.kind != graphql_1.Kind.INT) {
+                                if (field.value.kind !== 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;
@@ -2416,7 +2402,7 @@ class NormalizationFactory {
         if (data.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
             return false;
         }
-        if (data.fieldDataByName.size != 1) {
+        if (data.fieldDataByName.size !== 1) {
             return false;
         }
         for (const [fieldName, fieldData] of data.fieldDataByName) {
@@ -2436,7 +2422,7 @@ class NormalizationFactory {
         if (!(0, utils_4.isInputObjectDefinitionData)(streamConfigurationInputData)) {
             return false;
         }
-        if (streamConfigurationInputData.inputValueDataByName.size != 3) {
+        if (streamConfigurationInputData.inputValueDataByName.size !== 3) {
             return false;
         }
         for (const [inputValueName, inputValueData] of streamConfigurationInputData.inputValueDataByName) {
@@ -2672,7 +2658,7 @@ class NormalizationFactory {
         scalarDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByName, scalarDefinitionData.name);
         return scalarDefinitionData.node;
     }
-    getSchemaNodeByData(schemaData) {
+    schemaNodeFromData(schemaData) {
         const operationTypes = [];
         for (const [operation, { type: { name: { value }, }, },] of schemaData.operationTypes) {
             const data = this.parentDefinitionDataByTypeName.get(value);
@@ -2685,21 +2671,44 @@ class NormalizationFactory {
                 type: (0, utils_1.stringToNamedTypeNode)(value),
             });
         }
+        const linkResult = (0, utils_2.extractLinkArgs)(schemaData.directivesByName);
+        if (!linkResult.success) {
+            return linkResult;
+        }
+        this.importDataByDirectiveName = linkResult.importDataByDirectiveName;
+        const composeDirectives = schemaData.directivesByName.get(string_constants_1.COMPOSE_DIRECTIVE);
+        for (const composeDirective of composeDirectives ?? []) {
+            this.handleComposeDirective(composeDirective);
+        }
+        // If the directive is not part of @composeDirective, it is effectively ignored by federation.
+        for (const directiveName of this.importDataByDirectiveName.keys()) {
+            if (!this.federatedDirectiveDataByName.has(directiveName.substring(1))) {
+                this.importDataByDirectiveName.delete(directiveName);
+            }
+        }
         if (operationTypes.length > 0) {
-            const node = {
-                ...(schemaData.description ? { description: schemaData.description } : {}),
-                directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
-                kind: graphql_1.Kind.SCHEMA_DEFINITION,
-                operationTypes: operationTypes,
+            return {
+                node: {
+                    ...(schemaData.description ? { description: schemaData.description } : {}),
+                    directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
+                    kind: graphql_1.Kind.SCHEMA_DEFINITION,
+                    operationTypes: operationTypes,
+                },
+                success: true,
             };
-            return node;
         }
         if (schemaData.directivesByName.size < 1) {
-            return;
+            return {
+                node: undefined,
+                success: true,
+            };
         }
         return {
-            directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
-            kind: graphql_1.Kind.SCHEMA_EXTENSION,
+            node: {
+                directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
+                kind: graphql_1.Kind.SCHEMA_EXTENSION,
+            },
+            success: true,
         };
     }
     getUnionNodeByData(unionDefinitionData) {
@@ -2928,14 +2937,22 @@ class NormalizationFactory {
         const definitions = [];
         this.#addDirectiveDefinitionsToDocument(definitions);
         this.validateDirectives(this.schemaData, string_constants_1.SCHEMA);
-        const schemaNode = this.getSchemaNodeByData(this.schemaData);
+        const schemaNodeResult = this.schemaNodeFromData(this.schemaData);
+        if (!schemaNodeResult.success) {
+            this.errors.push(...schemaNodeResult.errors);
+            return {
+                errors: this.errors,
+                success: false,
+                warnings: this.warnings,
+            };
+        }
         /* Schema extension orphans are not supported on old routers.
          * Consequently, it is a breaking change that requires a new composition version, and that composition version
          * would only be compatible with newer routers that support schema extension orphans.
          * For now, only a valid schema definition node is pushed.
          */
-        if (schemaNode?.kind === graphql_1.Kind.SCHEMA_DEFINITION) {
-            definitions.push(schemaNode);
+        if (schemaNodeResult.node?.kind === graphql_1.Kind.SCHEMA_DEFINITION) {
+            definitions.push(schemaNodeResult.node);
         }
         for (const [parentTypeName, parentData] of this.parentDefinitionDataByTypeName) {
             this.validateDirectives(parentData, parentTypeName);
@@ -2983,7 +3000,7 @@ class NormalizationFactory {
                             // Undefined types are handled elsewhere
                             continue;
                         }
-                        this.sanitizeDefaultValue({ data: valueData, namedTypeData, node: valueData.node });
+                        (0, utils_4.sanitizeDefaultValue)({ data: valueData, namedTypeData, node: valueData.node });
                         if (!(0, utils_4.isInputNodeKind)(namedTypeData.kind)) {
                             this.errors.push((0, errors_1.invalidNamedTypeError)({
                                 data: valueData,
@@ -3161,15 +3178,7 @@ class NormalizationFactory {
                 this.warnings.push((0, warnings_1.unimplementedInterfaceOutputTypeWarning)(this.subgraphName, referencedTypeName));
             }
         }
-        const persistedDirectiveDefinitionDataByDirectiveName = new Map();
-        for (const directiveDefinitionNode of this.directiveDefinitionByName.values()) {
-            // TODO @composeDirective directives would also be handled here
-            const executableLocations = (0, utils_1.extractExecutableDirectiveLocations)(directiveDefinitionNode.locations, new Set());
-            if (executableLocations.size < 1) {
-                continue;
-            }
-            this.addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, executableLocations);
-        }
+        this.handleExecutableDirectives();
         if (this.isSubgraphEventDrivenGraph) {
             this.validateEventDrivenSubgraph();
         }
@@ -3190,16 +3199,19 @@ class NormalizationFactory {
         };
         return {
             authorizationDataByParentTypeName: this.authorizationDataByParentTypeName,
-            // configurationDataMap is map of ConfigurationData per type name.
-            // It is an Intermediate configuration object that will be converted to an engine configuration in the router
             concreteTypeNamesByAbstractTypeName: this.concreteTypeNamesByAbstractTypeName,
             conditionalFieldDataByCoordinates: this.conditionalFieldDataByCoords,
+            /* `configurationDataByTypeName` is an intermediate object that is converted
+             * to an engine configuration in the router
+             */
             configurationDataByTypeName: this.configurationDataByTypeName,
             costs: this.costs,
             directiveDefinitionByName: this.directiveDefinitionByName,
             entityDataByTypeName: this.entityDataByTypeName,
             entityInterfaces: this.entityInterfaceDataByTypeName,
+            federatedDirectiveDataByName: this.federatedDirectiveDataByName,
             fieldCoordsByNamedTypeName: this.fieldCoordsByNamedTypeName,
+            importDataByDirectiveName: this.importDataByDirectiveName,
             interfaceImplementationTypeNamesByInterfaceTypeName: this.interfaceImplementationTypeNamesByInterfaceTypeName,
             isEventDrivenGraph: this.isSubgraphEventDrivenGraph,
             isVersionTwo: this.isSubgraphVersionTwo,
@@ -3207,210 +3219,16 @@ class NormalizationFactory {
             keyFieldSetsByEntityTypeNameByKeyFieldCoords: this.keyFieldSetsByEntityTypeNameByFieldCoords,
             operationTypes: this.operationTypeNodeByTypeName,
             originalTypeNameByRenamedTypeName: this.originalTypeNameByRenamedTypeName,
-            overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
+            overriddenFieldNamesByParentTypeNameByTargetSubgraphName: this.overriddenFieldNamesByTypeNameByTargetSubgraphName,
             parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
-            persistedDirectiveDefinitionDataByDirectiveName,
-            schemaNode,
+            schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { addInvalidExtensionOrphans: true, assumeValid: true, assumeValidSDL: true }),
+            schemaNode: schemaNodeResult.node,
             subgraphAST: newAST,
             subgraphString: (0, graphql_1.print)(newAST),
-            schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { addInvalidExtensionOrphans: true, assumeValid: true, assumeValidSDL: true }),
             success: true,
             warnings: this.warnings,
         };
     }
 }
 exports.NormalizationFactory = NormalizationFactory;
-function batchNormalize({ options, subgraphs }) {
-    const authorizationDataByParentTypeName = new Map();
-    const concreteTypeNamesByAbstractTypeName = new Map();
-    const entityDataByTypeName = new Map();
-    const interfaceImplementationTypeNamesByInterfaceTypeName = new Map();
-    const internalSubgraphBySubgraphName = new Map();
-    const allOverridesByTargetSubgraphName = new Map();
-    const overrideSourceSubgraphNamesByFieldPath = new Map();
-    const duplicateOverriddenFieldPaths = new Set();
-    const parentDefinitionDataMapsBySubgraphName = new Map();
-    const subgraphNames = new Set();
-    const nonUniqueSubgraphNames = new Set();
-    const invalidNameErrorMessages = [];
-    const invalidORScopesCoords = new Set();
-    const fieldCoordsByNamedTypeName = new Map();
-    const warnings = [];
-    const validationErrors = [];
-    // Record the subgraph names first, so that subgraph references can be validated
-    for (const subgraph of subgraphs) {
-        if (subgraph.name) {
-            (0, subgraph_1.recordSubgraphName)(subgraph.name, subgraphNames, nonUniqueSubgraphNames);
-        }
-    }
-    const internalGraph = new graph_1.Graph();
-    for (let i = 0; i < subgraphs.length; i++) {
-        const subgraph = subgraphs[i];
-        const subgraphName = subgraph.name || `subgraph-${i}-${Date.now()}`;
-        if (!subgraph.name) {
-            invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
-        }
-        const normalizationResult = normalizeSubgraph({
-            document: subgraph.definitions,
-            internalGraph,
-            options,
-            subgraphName,
-        });
-        if (normalizationResult.warnings.length > 0) {
-            warnings.push(...normalizationResult.warnings);
-        }
-        if (!normalizationResult.success) {
-            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, normalizationResult.errors));
-            continue;
-        }
-        if (!normalizationResult) {
-            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, [errors_1.subgraphValidationFailureError]));
-            continue;
-        }
-        parentDefinitionDataMapsBySubgraphName.set(subgraphName, normalizationResult.parentDefinitionDataByTypeName);
-        for (const authorizationData of normalizationResult.authorizationDataByParentTypeName.values()) {
-            (0, utils_3.upsertAuthorizationData)(authorizationDataByParentTypeName, authorizationData, invalidORScopesCoords);
-        }
-        for (const [namedTypeName, fieldCoords] of normalizationResult.fieldCoordsByNamedTypeName) {
-            (0, utils_5.addIterableToSet)({
-                source: fieldCoords,
-                target: (0, utils_5.getValueOrDefault)(fieldCoordsByNamedTypeName, namedTypeName, () => new Set()),
-            });
-        }
-        for (const [abstractTypeName, incomingConcreteTypeNames,] of normalizationResult.concreteTypeNamesByAbstractTypeName) {
-            const existingConcreteTypeNames = concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
-            if (!existingConcreteTypeNames) {
-                concreteTypeNamesByAbstractTypeName.set(abstractTypeName, new Set(incomingConcreteTypeNames));
-                continue;
-            }
-            (0, utils_5.addIterableToSet)({
-                source: incomingConcreteTypeNames,
-                target: existingConcreteTypeNames,
-            });
-        }
-        for (const [interfaceTypeName, incomingInterfaceTypeNames,] of normalizationResult.interfaceImplementationTypeNamesByInterfaceTypeName) {
-            const existingInterfaceTypeNames = interfaceImplementationTypeNamesByInterfaceTypeName.get(interfaceTypeName);
-            if (!existingInterfaceTypeNames) {
-                interfaceImplementationTypeNamesByInterfaceTypeName.set(interfaceTypeName, new Set(incomingInterfaceTypeNames));
-                continue;
-            }
-            (0, utils_5.addIterableToSet)({
-                source: incomingInterfaceTypeNames,
-                target: existingInterfaceTypeNames,
-            });
-        }
-        for (const [typeName, entityData] of normalizationResult.entityDataByTypeName) {
-            const keyFieldSetDataByFieldSet = entityData.keyFieldSetDatasBySubgraphName.get(subgraphName);
-            if (!keyFieldSetDataByFieldSet) {
-                continue;
-            }
-            (0, utils_3.upsertEntityData)({
-                entityDataByTypeName,
-                keyFieldSetDataByFieldSet,
-                typeName,
-                subgraphName,
-            });
-        }
-        if (subgraph.name) {
-            internalSubgraphBySubgraphName.set(subgraphName, {
-                conditionalFieldDataByCoordinates: normalizationResult.conditionalFieldDataByCoordinates,
-                configurationDataByTypeName: normalizationResult.configurationDataByTypeName,
-                costs: normalizationResult.costs,
-                definitions: normalizationResult.subgraphAST,
-                directiveDefinitionByName: normalizationResult.directiveDefinitionByName,
-                entityInterfaces: normalizationResult.entityInterfaces,
-                isVersionTwo: normalizationResult.isVersionTwo,
-                keyFieldNamesByParentTypeName: normalizationResult.keyFieldNamesByParentTypeName,
-                name: subgraphName,
-                operationTypes: normalizationResult.operationTypes,
-                overriddenFieldNamesByParentTypeName: new Map(),
-                parentDefinitionDataByTypeName: normalizationResult.parentDefinitionDataByTypeName,
-                persistedDirectiveDefinitionDataByDirectiveName: normalizationResult.persistedDirectiveDefinitionDataByDirectiveName,
-                schema: normalizationResult.schema,
-                schemaNode: normalizationResult.schemaNode,
-                url: subgraph.url,
-            });
-        }
-        if (normalizationResult.overridesByTargetSubgraphName.size < 1) {
-            continue;
-        }
-        for (const [targetSubgraphName, overridesData] of normalizationResult.overridesByTargetSubgraphName) {
-            const isTargetValid = subgraphNames.has(targetSubgraphName);
-            for (const [parentTypeName, fieldNames] of overridesData) {
-                /* It's possible for a renamed root type to have a field overridden, so make sure any errors at this stage are
-                   propagated with the original typename. */
-                const originalParentTypeName = normalizationResult.originalTypeNameByRenamedTypeName.get(parentTypeName) || parentTypeName;
-                if (!isTargetValid) {
-                    warnings.push((0, warnings_1.invalidOverrideTargetSubgraphNameWarning)(targetSubgraphName, originalParentTypeName, [...fieldNames], subgraph.name));
-                }
-                else {
-                    const overridesData = (0, utils_5.getValueOrDefault)(allOverridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-                    const existingFieldNames = (0, utils_5.getValueOrDefault)(overridesData, parentTypeName, () => new Set(fieldNames));
-                    (0, utils_5.addIterableToSet)({
-                        source: fieldNames,
-                        target: existingFieldNames,
-                    });
-                }
-                for (const fieldName of fieldNames) {
-                    const fieldCoords = `${originalParentTypeName}.${fieldName}`;
-                    const sourceSubgraphs = overrideSourceSubgraphNamesByFieldPath.get(fieldCoords);
-                    if (!sourceSubgraphs) {
-                        overrideSourceSubgraphNamesByFieldPath.set(fieldCoords, [subgraphName]);
-                        continue;
-                    }
-                    sourceSubgraphs.push(subgraphName);
-                    duplicateOverriddenFieldPaths.add(fieldCoords);
-                }
-            }
-        }
-    }
-    const allErrors = [];
-    if (invalidORScopesCoords.size > 0) {
-        allErrors.push((0, errors_1.orScopesLimitError)(constants_1.MAX_OR_SCOPES, [...invalidORScopesCoords]));
-    }
-    if (invalidNameErrorMessages.length > 0 || nonUniqueSubgraphNames.size > 0) {
-        allErrors.push((0, errors_1.invalidSubgraphNamesError)([...nonUniqueSubgraphNames], invalidNameErrorMessages));
-    }
-    if (duplicateOverriddenFieldPaths.size > 0) {
-        const duplicateOverriddenFieldErrorMessages = [];
-        for (const fieldPath of duplicateOverriddenFieldPaths) {
-            const sourceSubgraphNames = (0, utils_5.getOrThrowError)(overrideSourceSubgraphNamesByFieldPath, fieldPath, 'overrideSourceSubgraphNamesByFieldPath');
-            duplicateOverriddenFieldErrorMessages.push((0, errors_1.duplicateOverriddenFieldErrorMessage)(fieldPath, sourceSubgraphNames));
-        }
-        allErrors.push((0, errors_1.duplicateOverriddenFieldsError)(duplicateOverriddenFieldErrorMessages));
-    }
-    allErrors.push(...validationErrors);
-    if (allErrors.length > 0) {
-        return {
-            errors: allErrors,
-            success: false,
-            warnings,
-        };
-    }
-    for (const [targetSubgraphName, overridesData] of allOverridesByTargetSubgraphName) {
-        const internalSubgraph = (0, utils_5.getOrThrowError)(internalSubgraphBySubgraphName, targetSubgraphName, 'internalSubgraphBySubgraphName');
-        internalSubgraph.overriddenFieldNamesByParentTypeName = overridesData;
-        for (const [parentTypeName, fieldNames] of overridesData) {
-            const configurationData = internalSubgraph.configurationDataByTypeName.get(parentTypeName);
-            if (!configurationData) {
-                continue;
-            }
-            (0, utils_3.subtractSet)(fieldNames, configurationData.fieldNames);
-            if (configurationData.fieldNames.size < 1) {
-                internalSubgraph.configurationDataByTypeName.delete(parentTypeName);
-            }
-        }
-    }
-    return {
-        authorizationDataByParentTypeName,
-        concreteTypeNamesByAbstractTypeName,
-        entityDataByTypeName,
-        fieldCoordsByNamedTypeName,
-        interfaceImplementationTypeNamesByInterfaceTypeName,
-        internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
-        internalGraph,
-        success: true,
-        warnings,
-    };
-}
 //# sourceMappingURL=normalization-factory.js.map