@wundergraph/composition 0.36.1 → 0.37.1

package/dist/{normalization → v1/normalization}/normalization-factory.js

@@ -5,26 +5,31 @@ exports.normalizeSubgraphFromString = normalizeSubgraphFromString;
 exports.normalizeSubgraph = normalizeSubgraph;
 exports.batchNormalize = batchNormalize;
 const graphql_1 = require("graphql");
-const utils_1 = require("../ast/utils");
+const utils_1 = require("../../ast/utils");
 const utils_2 = require("./utils");
 const constants_1 = require("../utils/constants");
 const utils_3 = require("../utils/utils");
-const errors_1 = require("../errors/errors");
+const errors_1 = require("../../errors/errors");
 const string_constants_1 = require("../utils/string-constants");
-const buildASTSchema_1 = require("../buildASTSchema/buildASTSchema");
+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 type_definition_data_1 = require("../schema-building/type-definition-data");
-const utils_4 = require("../schema-building/utils");
-const ast_1 = require("../schema-building/ast");
-const graph_1 = require("../resolvability-graph/graph");
+const types_1 = require("../../schema-building/types");
+const utils_4 = require("../../schema-building/utils");
+const ast_1 = require("../../schema-building/ast");
+const graph_1 = require("../../resolvability-graph/graph");
 const integer_constants_1 = require("../utils/integer-constants");
+const string_constants_2 = require("../../utils/string-constants");
+const integer_constants_2 = require("../../utils/integer-constants");
+const utils_5 = require("../../utils/utils");
+const index_1 = require("graphql/index");
+const utils_6 = require("../../router-configuration/utils");
 function normalizeSubgraphFromString(subgraphSDL, noLocation = true) {
     const { error, documentNode } = (0, utils_1.safeParse)(subgraphSDL, noLocation);
     if (error || !documentNode) {
-        return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(error)], warnings: [] };
+        return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(error)], success: false, warnings: [] };
     }
     const normalizationFactory = new NormalizationFactory(new graph_1.Graph());
     return normalizationFactory.normalize(documentNode);
@@ -38,8 +43,8 @@ class NormalizationFactory {
     authorizationDataByParentTypeName = new Map();
     childName = '';
     concreteTypeNamesByAbstractTypeName = new Map();
-    conditionalFieldDataByCoordinates = new Map();
-    configurationDataByParentTypeName = new Map();
+    conditionalFieldDataByCoords = new Map();
+    configurationDataByTypeName = new Map();
     customDirectiveDefinitions = new Map();
     definedDirectiveNames = new Set();
     directiveDefinitionByDirectiveName = new Map();
@@ -49,7 +54,8 @@ class NormalizationFactory {
     entityDataByTypeName = new Map();
     entityInterfaceDataByTypeName = new Map();
     eventsConfigurations = new Map();
-    unvalidatedExternalFieldCoords = new Set();
+    fieldSetDataByTypeName = new Map();
+    heirFieldAuthorizationDataByTypeName = new Map();
     interfaceTypeNamesWithAuthorizationDirectives = new Set();
     internalGraph;
     invalidConfigureDescriptionNodeDatas = [];
@@ -59,8 +65,7 @@ class NormalizationFactory {
     isParentObjectShareable = false;
     isSubgraphEventDrivenGraph = false;
     isSubgraphVersionTwo = false;
-    fieldSetDataByTypeName = new Map();
-    heirFieldAuthorizationDataByTypeName = new Map();
+    keyFieldSetDatasByTypeName = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
     lastChildNodeKind = graphql_1.Kind.NULL;
     leafTypeNamesWithAuthorizationDirectives = new Set();
@@ -78,19 +83,20 @@ class NormalizationFactory {
     referencedTypeNames = new Set();
     renamedParentTypeName = '';
     subgraphName;
+    unvalidatedExternalFieldCoords = new Set();
     usesEdfsNatsStreamConfiguration = false;
     warnings = [];
     constructor(internalGraph, subgraphName) {
         for (const [baseDirectiveName, baseDirectiveDefinition] of constants_1.BASE_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME) {
             this.directiveDefinitionByDirectiveName.set(baseDirectiveName, baseDirectiveDefinition);
         }
-        this.subgraphName = subgraphName || string_constants_1.NOT_APPLICABLE;
+        this.subgraphName = subgraphName || string_constants_2.NOT_APPLICABLE;
         this.internalGraph = internalGraph;
         this.internalGraph.setSubgraphName(this.subgraphName);
         this.schemaData = {
             directivesByDirectiveName: new Map(),
             kind: graphql_1.Kind.SCHEMA_DEFINITION,
-            name: string_constants_1.SCHEMA,
+            name: string_constants_2.SCHEMA,
             operationTypes: new Map(),
         };
     }
@@ -109,7 +115,7 @@ class NormalizationFactory {
             case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                 return { hasUnhandledError: false, typeString: '' };
             default:
-                return { hasUnhandledError: true, typeString: (0, utils_3.kindToTypeString)(parentData.kind) };
+                return { hasUnhandledError: true, typeString: (0, utils_5.kindToTypeString)(parentData.kind) };
         }
     }
     validateArguments(fieldData, fieldPath) {
@@ -142,7 +148,7 @@ class NormalizationFactory {
         const requiresScopes = [];
         for (const directiveNode of node.directives) {
             const directiveName = directiveNode.name.value;
-            if (directiveName === string_constants_1.AUTHENTICATED) {
+            if (directiveName === string_constants_2.AUTHENTICATED) {
                 // @authenticated is not repeatable
                 if (requiresAuthentication) {
                     return;
@@ -150,7 +156,7 @@ class NormalizationFactory {
                 requiresAuthentication = true;
                 continue;
             }
-            if (directiveName !== string_constants_1.REQUIRES_SCOPES) {
+            if (directiveName !== string_constants_2.REQUIRES_SCOPES) {
                 continue;
             }
             // @requiresScopes is not repeatable
@@ -178,7 +184,7 @@ class NormalizationFactory {
             return;
         }
         const scopesArgument = directiveNode.arguments[0];
-        if (scopesArgument.name.value !== string_constants_1.SCOPES || scopesArgument.value.kind !== graphql_1.Kind.LIST) {
+        if (scopesArgument.name.value !== string_constants_2.SCOPES || scopesArgument.value.kind !== graphql_1.Kind.LIST) {
             return;
         }
         const orScopes = scopesArgument.value.values;
@@ -207,7 +213,7 @@ class NormalizationFactory {
         return authorizationData;
     }
     isTypeNameRootType(typeName) {
-        return string_constants_1.ROOT_TYPE_NAMES.has(typeName) || this.operationTypeNodeByTypeName.has(typeName);
+        return string_constants_2.ROOT_TYPE_NAMES.has(typeName) || this.operationTypeNodeByTypeName.has(typeName);
     }
     isArgumentValueValid(typeNode, argumentValue) {
         if (argumentValue.kind === graphql_1.Kind.NULL) {
@@ -228,37 +234,37 @@ class NormalizationFactory {
             }
             case graphql_1.Kind.NAMED_TYPE: {
                 switch (typeNode.name.value) {
-                    case string_constants_1.BOOLEAN_SCALAR: {
+                    case string_constants_2.BOOLEAN_SCALAR: {
                         return argumentValue.kind === graphql_1.Kind.BOOLEAN;
                     }
-                    case string_constants_1.FLOAT_SCALAR: {
+                    case string_constants_2.FLOAT_SCALAR: {
                         return argumentValue.kind === graphql_1.Kind.FLOAT || argumentValue.kind === graphql_1.Kind.INT;
                     }
-                    case string_constants_1.ID_SCALAR: {
+                    case string_constants_2.ID_SCALAR: {
                         return argumentValue.kind === graphql_1.Kind.STRING || argumentValue.kind === graphql_1.Kind.INT;
                     }
-                    case string_constants_1.INT_SCALAR: {
+                    case string_constants_2.INT_SCALAR: {
                         return argumentValue.kind === graphql_1.Kind.INT;
                     }
-                    case string_constants_1.FIELD_SET_SCALAR:
+                    case string_constants_2.FIELD_SET_SCALAR:
                     // intentional fallthrough
-                    case string_constants_1.SCOPE_SCALAR:
+                    case string_constants_2.SCOPE_SCALAR:
                     // intentional fallthrough
-                    case string_constants_1.STRING_SCALAR: {
+                    case string_constants_2.STRING_SCALAR: {
                         return argumentValue.kind === graphql_1.Kind.STRING;
                     }
-                    case string_constants_1.LINK_IMPORT: {
+                    case string_constants_2.LINK_IMPORT: {
                         return true;
                     }
-                    case string_constants_1.LINK_PURPOSE: {
+                    case string_constants_2.LINK_PURPOSE: {
                         if (argumentValue.kind !== graphql_1.Kind.ENUM) {
                             return false;
                         }
-                        return argumentValue.value === string_constants_1.SECURITY || argumentValue.value === string_constants_1.EXECUTION;
+                        return argumentValue.value === string_constants_2.SECURITY || argumentValue.value === string_constants_2.EXECUTION;
                     }
-                    case string_constants_1.SUBSCRIPTION_FIELD_CONDITION:
+                    case string_constants_2.SUBSCRIPTION_FIELD_CONDITION:
                     // intentional fallthrough
-                    case string_constants_1.SUBSCRIPTION_FILTER_CONDITION:
+                    case string_constants_2.SUBSCRIPTION_FILTER_CONDITION:
                         return argumentValue.kind === graphql_1.Kind.OBJECT;
                     default: {
                         const parentData = this.parentDefinitionDataByTypeName.get(typeNode.name.value);
@@ -277,7 +283,7 @@ class NormalizationFactory {
                             if (!enumValue) {
                                 return false;
                             }
-                            return !enumValue.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+                            return !enumValue.directivesByDirectiveName.has(string_constants_2.INACCESSIBLE);
                         }
                         if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
                             return false;
@@ -294,10 +300,10 @@ class NormalizationFactory {
     }
     addInheritedDirectivesToFieldData(fieldDirectivesByDirectiveName) {
         if (this.isParentObjectShareable) {
-            (0, utils_3.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_1.SHAREABLE, () => [(0, utils_3.generateSimpleDirective)(string_constants_1.SHAREABLE)]);
+            (0, utils_5.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_2.SHAREABLE, () => [(0, utils_5.generateSimpleDirective)(string_constants_2.SHAREABLE)]);
         }
         if (this.isParentObjectExternal) {
-            (0, utils_3.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_1.EXTERNAL, () => [(0, utils_3.generateSimpleDirective)(string_constants_1.EXTERNAL)]);
+            (0, utils_5.getValueOrDefault)(fieldDirectivesByDirectiveName, string_constants_2.EXTERNAL, () => [(0, utils_5.generateSimpleDirective)(string_constants_2.EXTERNAL)]);
         }
         return fieldDirectivesByDirectiveName;
     }
@@ -308,26 +314,26 @@ class NormalizationFactory {
         for (const directiveNode of node.directives) {
             const directiveName = directiveNode.name.value;
             // Don't create pointless repetitions of @shareable
-            if (directiveName === string_constants_1.SHAREABLE) {
-                (0, utils_3.getValueOrDefault)(directivesByDirectiveName, directiveName, () => [directiveNode]);
+            if (directiveName === string_constants_2.SHAREABLE) {
+                (0, utils_5.getValueOrDefault)(directivesByDirectiveName, directiveName, () => [directiveNode]);
             }
             else {
-                (0, utils_3.getValueOrDefault)(directivesByDirectiveName, directiveName, () => []).push(directiveNode);
+                (0, utils_5.getValueOrDefault)(directivesByDirectiveName, directiveName, () => []).push(directiveNode);
             }
             if (!(0, utils_3.isNodeKindObject)(node.kind)) {
                 continue;
             }
-            this.isParentObjectExternal ||= directiveName === string_constants_1.EXTERNAL;
-            this.isParentObjectShareable ||= directiveName === string_constants_1.SHAREABLE;
+            this.isParentObjectExternal ||= directiveName === string_constants_2.EXTERNAL;
+            this.isParentObjectShareable ||= directiveName === string_constants_2.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;
+        const isAuthenticated = directiveName === string_constants_2.AUTHENTICATED;
+        const isOverride = directiveName === string_constants_2.OVERRIDE;
+        const isRequiresScopes = directiveName === string_constants_2.REQUIRES_SCOPES;
         if (!directiveNode.arguments || directiveNode.arguments.length < 1) {
             if (definitionData.requiredArgumentNames.size > 0) {
                 errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, requiredArgumentNames, []));
@@ -367,7 +373,7 @@ class NormalizationFactory {
                 });
                 continue;
             }
-            if (!isRequiresScopes || argumentName !== string_constants_1.SCOPES) {
+            if (!isRequiresScopes || argumentName !== string_constants_2.SCOPES) {
                 continue;
             }
             this.handleRequiresScopesDirective({
@@ -383,7 +389,7 @@ class NormalizationFactory {
         if (unexpectedArgumentNames.size > 0) {
             errorMessages.push((0, errors_1.unexpectedDirectiveArgumentErrorMessage)(directiveName, [...unexpectedArgumentNames]));
         }
-        const undefinedArgumentNames = (0, utils_3.getEntriesNotInHashSet)(requiredArgumentNames, definedArgumentNames);
+        const undefinedArgumentNames = (0, utils_5.getEntriesNotInHashSet)(requiredArgumentNames, definedArgumentNames);
         if (undefinedArgumentNames.length > 0) {
             errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, requiredArgumentNames, undefinedArgumentNames));
         }
@@ -398,7 +404,7 @@ class NormalizationFactory {
         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 parentAuthorizationData = (0, utils_5.getValueOrDefault)(this.authorizationDataByParentTypeName, parentTypeName, () => (0, utils_3.newAuthorizationData)(parentTypeName));
         const authorizationData = (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, data.node);
         authorizationData.requiredScopes.push(...requiredScopes);
         return errorMessages;
@@ -420,7 +426,7 @@ class NormalizationFactory {
                 definitionErrorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(directiveName, directiveLocation));
             }
             if (directiveNodes.length > 1 && !definitionData.isRepeatable) {
-                const handledDirectiveNames = (0, utils_3.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
+                const handledDirectiveNames = (0, utils_5.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
                 if (!handledDirectiveNames.has(directiveName)) {
                     handledDirectiveNames.add(directiveName);
                     definitionErrorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName));
@@ -437,7 +443,7 @@ class NormalizationFactory {
                     requiredArgumentNames,
                 });
                 if (errorMessages.length > 0) {
-                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, directiveCoords, (0, utils_3.numberToOrdinal)(i + 1), errorMessages));
+                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, directiveCoords, (0, utils_5.numberToOrdinal)(i + 1), errorMessages));
                 }
             }
         }
@@ -480,29 +486,29 @@ class NormalizationFactory {
     getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType = false) {
         // If the extend keyword is present, it's simply an extension
         if (isRealExtension) {
-            return type_definition_data_1.ExtensionType.REAL;
+            return types_1.ExtensionType.REAL;
         }
         /*
          * @extends is not interpreted as an extension under the following circumstances:
          * 1. It's a root type
-         * 2. It's a V2 subgraph
+         * 2. It's a V2 subgraph (but extends is temporarily propagated to handle @external key fields)
          * 3. And (of course) if @extends isn't defined at all
          */
-        if (isRootType || this.isSubgraphVersionTwo || !directivesByDirectiveName.has(string_constants_1.EXTENDS)) {
-            return type_definition_data_1.ExtensionType.NONE;
+        if (isRootType || !directivesByDirectiveName.has(string_constants_2.EXTENDS)) {
+            return types_1.ExtensionType.NONE;
         }
-        // If it's a V1 subgraph and defines @extends, it is considered an extension across subgraphs
-        return type_definition_data_1.ExtensionType.EXTENDS;
+        // If a V1 non-root Object defines @extends, it is considered an extension across subgraphs.
+        return types_1.ExtensionType.EXTENDS;
     }
     setParentDataExtensionType(parentData, incomingExtensionType) {
         switch (parentData.extensionType) {
-            case type_definition_data_1.ExtensionType.EXTENDS:
+            case types_1.ExtensionType.EXTENDS:
             // intentional fallthrough
-            case type_definition_data_1.ExtensionType.NONE: {
-                if (incomingExtensionType === type_definition_data_1.ExtensionType.REAL) {
+            case types_1.ExtensionType.NONE: {
+                if (incomingExtensionType === types_1.ExtensionType.REAL) {
                     return;
                 }
-                this.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(parentData.kind), parentData.name));
+                this.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_5.kindToTypeString)(parentData.kind), parentData.name));
                 return;
             }
             default: {
@@ -527,14 +533,14 @@ class NormalizationFactory {
         };
         for (const argument of directiveNode.arguments) {
             switch (argument.name.value) {
-                case string_constants_1.PROPAGATE: {
+                case string_constants_2.PROPAGATE: {
                     if (argument.value.kind != graphql_1.Kind.BOOLEAN) {
                         return;
                     }
                     configureDescriptionData.propagate = argument.value.value;
                     break;
                 }
-                case string_constants_1.DESCRIPTION_OVERRIDE: {
+                case string_constants_2.DESCRIPTION_OVERRIDE: {
                     if (argument.value.kind != graphql_1.Kind.STRING) {
                         return;
                     }
@@ -552,7 +558,7 @@ class NormalizationFactory {
         data.configureDescriptionDataBySubgraphName.set(this.subgraphName, configureDescriptionData);
     }
     extractConfigureDescriptionsData(data) {
-        const configureDescriptionNodes = data.directivesByDirectiveName.get(string_constants_1.CONFIGURE_DESCRIPTION);
+        const configureDescriptionNodes = data.directivesByDirectiveName.get(string_constants_2.CONFIGURE_DESCRIPTION);
         if (configureDescriptionNodes && configureDescriptionNodes.length == 1) {
             this.extractConfigureDescriptionData(data, configureDescriptionNodes[0]);
         }
@@ -581,13 +587,13 @@ class NormalizationFactory {
         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.isEntity ||= data.directivesByDirectiveName.has(string_constants_2.KEY);
+        data.isInaccessible ||= data.directivesByDirectiveName.has(string_constants_2.INACCESSIBLE);
         data.subgraphNames.add(this.subgraphName);
     }
     addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames, concreteTypeName) {
         for (const interfaceName of interfaceTypeNames) {
-            (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, interfaceName, () => new Set()).add(concreteTypeName);
+            (0, utils_5.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, interfaceName, () => new Set()).add(concreteTypeName);
             this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(interfaceName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(concreteTypeName), concreteTypeName, true);
         }
     }
@@ -637,7 +643,7 @@ class NormalizationFactory {
             if (handledLocations.has(locationName)) {
                 continue;
             }
-            if (!string_constants_1.EXECUTABLE_DIRECTIVE_LOCATIONS.has(locationName) && !string_constants_1.TYPE_SYSTEM_DIRECTIVE_LOCATIONS.has(locationName)) {
+            if (!string_constants_2.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;
@@ -722,27 +728,25 @@ class NormalizationFactory {
     }
     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 fieldCoords = `${this.originalParentTypeName}.${name}`;
+        const { isExternal, isShareable } = (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],
+            externalFieldDataBySubgraphName: new Map([
+                [this.subgraphName, (0, utils_4.newExternalFieldData)(isExternal)],
             ]),
+            isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
+            isShareableBySubgraphName: new Map([[this.subgraphName, isShareable]]),
             kind: graphql_1.Kind.FIELD_DEFINITION,
             name,
             namedTypeName: (0, ast_1.getTypeNodeNamedTypeName)(node.type),
-            node: (0, ast_1.getMutableFieldNode)(node, fieldPath, this.errors),
+            node: (0, ast_1.getMutableFieldNode)(node, fieldCoords, 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),
+            type: (0, ast_1.getMutableTypeNode)(node.type, fieldCoords, this.errors),
             directivesByDirectiveName,
             description: (0, utils_1.formatDescription)(node.description),
         };
@@ -755,7 +759,7 @@ class NormalizationFactory {
         // 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)));
+            this.errors.push((0, errors_1.incompatibleInputValueDefaultValueTypeError)((isArgument ? string_constants_2.ARGUMENT : string_constants_2.INPUT_FIELD) + ` "${name}"`, originalPath, (0, merge_1.printTypeNode)(node.type), (0, graphql_1.print)(node.defaultValue)));
         }
         const inputValueData = {
             configureDescriptionDataBySubgraphName: new Map(),
@@ -790,7 +794,7 @@ class NormalizationFactory {
         }
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.updateCompositeOutputDataByNode(node, parentData, extensionType);
@@ -802,8 +806,8 @@ class NormalizationFactory {
             extensionType,
             fieldDataByFieldName: new Map(),
             implementedInterfaceTypeNames: this.extractImplementedInterfaceTypeNames(node, new Set()),
-            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isEntity: directivesByDirectiveName.has(string_constants_2.KEY),
+            isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
             kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInterfaceNode)(node.name),
@@ -821,11 +825,11 @@ class NormalizationFactory {
         }
         switch (operationTypeNode) {
             case graphql_1.OperationTypeNode.MUTATION:
-                return string_constants_1.MUTATION;
+                return string_constants_2.MUTATION;
             case graphql_1.OperationTypeNode.SUBSCRIPTION:
-                return string_constants_1.SUBSCRIPTION;
+                return string_constants_2.SUBSCRIPTION;
             default:
-                return string_constants_1.QUERY;
+                return string_constants_2.QUERY;
         }
     }
     addInterfaceObjectFieldsByNode(node) {
@@ -847,7 +851,7 @@ class NormalizationFactory {
         this.addInterfaceObjectFieldsByNode(node);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.updateCompositeOutputDataByNode(node, parentData, extensionType);
@@ -862,8 +866,8 @@ class NormalizationFactory {
             extensionType,
             fieldDataByFieldName: new Map(),
             implementedInterfaceTypeNames,
-            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isEntity: directivesByDirectiveName.has(string_constants_2.KEY),
+            isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
             isRootType,
             kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
             name: typeName,
@@ -884,7 +888,7 @@ class NormalizationFactory {
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
@@ -916,11 +920,11 @@ class NormalizationFactory {
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
-            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_2.INACCESSIBLE);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             this.extractConfigureDescriptionsData(parentData);
@@ -931,7 +935,7 @@ class NormalizationFactory {
             directivesByDirectiveName,
             extensionType,
             inputValueDataByValueName: new Map(),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
             kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInputObjectNode)(node.name),
@@ -950,7 +954,7 @@ class NormalizationFactory {
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
@@ -982,7 +986,7 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.duplicateUnionMemberDefinitionError)(unionTypeName, memberTypeName));
                 continue;
             }
-            (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, unionTypeName, () => new Set()).add(memberTypeName);
+            (0, utils_5.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, unionTypeName, () => new Set()).add(memberTypeName);
             /*
              * Scalars are never valid Union member types.
              * However, base scalars are not upserted to the type definition data.
@@ -1005,7 +1009,7 @@ class NormalizationFactory {
         this.addConcreteTypeNamesForUnion(node);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.UNION_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
@@ -1028,51 +1032,373 @@ class NormalizationFactory {
         this.extractConfigureDescriptionsData(newParentData);
         this.parentDefinitionDataByTypeName.set(typeName, newParentData);
     }
-    extractKeyFieldSets(node, keyFieldSetData) {
-        const isUnresolvableByRawKeyFieldSet = keyFieldSetData.isUnresolvableByKeyFieldSet;
+    extractKeyFieldSets(node, keyFieldSetDataByFieldSet) {
         const parentTypeName = node.name.value;
         if (!node.directives?.length) {
             // This should never happen
             this.errors.push((0, errors_1.expectedEntityError)(parentTypeName));
             return;
         }
-        // validation happens elsewhere
+        // full validation happens elsewhere
+        let keyNumber = 0;
         for (const directive of node.directives) {
-            if (directive.name.value !== string_constants_1.KEY) {
+            if (directive.name.value !== string_constants_2.KEY) {
                 continue;
             }
+            keyNumber += 1;
             if (!directive.arguments || directive.arguments.length < 1) {
                 continue;
             }
-            let keyFieldSet;
+            let rawFieldSet;
             let isUnresolvable = false;
             for (const arg of directive.arguments) {
-                if (arg.name.value === string_constants_1.RESOLVABLE) {
+                if (arg.name.value === string_constants_2.RESOLVABLE) {
                     if (arg.value.kind === graphql_1.Kind.BOOLEAN && !arg.value.value) {
                         isUnresolvable = true;
                     }
                     continue;
                 }
-                if (arg.name.value !== string_constants_1.FIELDS) {
-                    keyFieldSet = undefined;
+                if (arg.name.value !== string_constants_2.FIELDS) {
+                    rawFieldSet = undefined;
                     break;
                 }
                 if (arg.value.kind !== graphql_1.Kind.STRING) {
-                    keyFieldSet = undefined;
+                    rawFieldSet = undefined;
                     break;
                 }
-                keyFieldSet = arg.value.value;
+                rawFieldSet = arg.value.value;
+            }
+            if (rawFieldSet === undefined) {
+                continue;
+            }
+            const { error, documentNode } = (0, utils_1.safeParse)('{' + rawFieldSet + '}');
+            if (error || !documentNode) {
+                this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_2.KEY, parentTypeName, (0, utils_5.numberToOrdinal)(keyNumber), [
+                    (0, errors_1.unparsableFieldSetErrorMessage)(rawFieldSet, error),
+                ]));
+                continue;
+            }
+            const normalizedFieldSet = (0, utils_2.getNormalizedFieldSet)(documentNode);
+            const keyFieldSetData = keyFieldSetDataByFieldSet.get(normalizedFieldSet);
+            if (keyFieldSetData) {
+                // Duplicate keys should potentially be a warning. For now, simply propagate if it's resolvable.
+                keyFieldSetData.isUnresolvable ||= isUnresolvable;
+            }
+            else {
+                keyFieldSetDataByFieldSet.set(normalizedFieldSet, {
+                    documentNode,
+                    isUnresolvable,
+                    normalizedFieldSet,
+                    rawFieldSet,
+                });
+            }
+        }
+    }
+    getFieldSetParent(isProvides, parentData, fieldName, parentTypeName) {
+        if (!isProvides) {
+            return { fieldSetParentData: parentData };
+        }
+        const fieldData = (0, utils_5.getOrThrowError)(parentData.fieldDataByFieldName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
+        const fieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+        const namedTypeData = this.parentDefinitionDataByTypeName.get(fieldNamedTypeName);
+        // This error should never happen
+        if (!namedTypeData) {
+            return {
+                errorString: (0, errors_1.unknownNamedTypeErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+            };
+        }
+        if (namedTypeData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION && namedTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            return {
+                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+            };
+        }
+        return { fieldSetParentData: namedTypeData };
+    }
+    validateConditionalFieldSet(selectionSetParentData, fieldSet, directiveFieldName, isProvides, directiveParentTypeName) {
+        // Create a new selection set so that the value can be parsed as a new DocumentNode
+        const { error, documentNode } = (0, utils_1.safeParse)('{' + fieldSet + '}');
+        if (error || !documentNode) {
+            return { errorMessages: [(0, errors_1.unparsableFieldSetErrorMessage)(fieldSet, error)] };
+        }
+        const nf = this;
+        const parentDatas = [selectionSetParentData];
+        const directiveName = (0, utils_2.getConditionalFieldSetDirectiveName)(isProvides);
+        const definedFields = [];
+        const directiveCoords = `${directiveParentTypeName}.${directiveFieldName}`;
+        const fieldCoordsPath = (0, utils_2.getInitialFieldCoordsPath)(isProvides, directiveCoords);
+        const fieldPath = [directiveFieldName];
+        const externalAncestors = new Set();
+        const errorMessages = [];
+        let currentDepth = -1;
+        let shouldDefineSelectionSet = true;
+        let lastFieldName = directiveFieldName;
+        let hasConditionalField = false;
+        (0, index_1.visit)(documentNode, {
+            Argument: {
+                enter() {
+                    return false;
+                },
+            },
+            Field: {
+                enter(node) {
+                    const parentData = parentDatas[currentDepth];
+                    const parentTypeName = parentData.name;
+                    if (parentData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
+                        errorMessages.push((0, errors_1.invalidSelectionOnUnionErrorMessage)(fieldSet, fieldCoordsPath, parentTypeName));
+                        return index_1.BREAK;
+                    }
+                    const fieldName = node.name.value;
+                    const currentFieldCoords = `${parentTypeName}.${fieldName}`;
+                    nf.unvalidatedExternalFieldCoords.delete(currentFieldCoords);
+                    // If an object-like was just visited, a selection set should have been entered
+                    if (shouldDefineSelectionSet) {
+                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, fieldCoordsPath, parentTypeName, (0, utils_5.kindToTypeString)(parentData.kind)));
+                        return index_1.BREAK;
+                    }
+                    fieldCoordsPath.push(currentFieldCoords);
+                    fieldPath.push(fieldName);
+                    lastFieldName = fieldName;
+                    const fieldData = parentData.fieldDataByFieldName.get(fieldName);
+                    // undefined if the field does not exist on the parent
+                    if (!fieldData) {
+                        errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentTypeName, fieldName));
+                        return index_1.BREAK;
+                    }
+                    if (definedFields[currentDepth].has(fieldName)) {
+                        errorMessages.push((0, errors_1.duplicateFieldInFieldSetErrorMessage)(fieldSet, currentFieldCoords));
+                        return index_1.BREAK;
+                    }
+                    definedFields[currentDepth].add(fieldName);
+                    const { isDefinedExternal, isUnconditionallyProvided } = (0, utils_5.getOrThrowError)(fieldData.externalFieldDataBySubgraphName, nf.subgraphName, `${currentFieldCoords}.externalFieldDataBySubgraphName`);
+                    const isFieldConditional = isDefinedExternal && !isUnconditionallyProvided;
+                    if (!isUnconditionallyProvided) {
+                        hasConditionalField = true;
+                    }
+                    const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+                    // The child could itself be a parent
+                    const namedTypeData = nf.parentDefinitionDataByTypeName.get(namedTypeName);
+                    // The base scalars are not in the parents map
+                    if (constants_1.BASE_SCALARS.has(namedTypeName) ||
+                        namedTypeData?.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+                        namedTypeData?.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
+                        if (externalAncestors.size < 1 && !isDefinedExternal) {
+                            if (nf.isSubgraphVersionTwo) {
+                                nf.errors.push((0, errors_1.nonExternalConditionalFieldError)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
+                                return;
+                            }
+                            /* In V1, @requires and @provides do not need to declare any part of the field set @external.
+                             * It would appear that any such non-external fields are treated as if they are non-conditionally provided.
+                             * */
+                            nf.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
+                            return;
+                        }
+                        if (externalAncestors.size < 1 && isUnconditionallyProvided) {
+                            // V2 subgraphs return an error when an external key field on an entity extension is provided.
+                            if (nf.isSubgraphVersionTwo) {
+                                errorMessages.push((0, errors_1.fieldAlreadyProvidedErrorMessage)(currentFieldCoords, nf.subgraphName, directiveName));
+                            }
+                            else {
+                                nf.warnings.push((0, warnings_1.fieldAlreadyProvidedWarning)(currentFieldCoords, directiveName, directiveCoords, nf.subgraphName));
+                            }
+                            return;
+                        }
+                        // @TODO re-assess in v2 because this would be breaking for @provides in v1
+                        if (!isFieldConditional && !isProvides) {
+                            // Do not add unnecessary @requires configurations
+                            return;
+                        }
+                        const conditionalFieldData = (0, utils_5.getValueOrDefault)(nf.conditionalFieldDataByCoords, currentFieldCoords, utils_4.newConditionalFieldData);
+                        const fieldSetCondition = (0, utils_6.newFieldSetConditionData)({
+                            fieldCoordinatesPath: [...fieldCoordsPath],
+                            fieldPath: [...fieldPath],
+                        });
+                        isProvides
+                            ? conditionalFieldData.providedBy.push(fieldSetCondition)
+                            : conditionalFieldData.requiredBy.push(fieldSetCondition);
+                        return;
+                    }
+                    if (!namedTypeData) {
+                        // Should not be possible to receive this error
+                        errorMessages.push((0, errors_1.unknownTypeInFieldSetErrorMessage)(fieldSet, currentFieldCoords, namedTypeName));
+                        return index_1.BREAK;
+                    }
+                    // TODO isFieldConditional
+                    if (isDefinedExternal) {
+                        if (isProvides) {
+                            (0, utils_5.getValueOrDefault)(nf.conditionalFieldDataByCoords, currentFieldCoords, utils_4.newConditionalFieldData).providedBy.push((0, utils_6.newFieldSetConditionData)({
+                                fieldCoordinatesPath: [...fieldCoordsPath],
+                                fieldPath: [...fieldPath],
+                            }));
+                        }
+                        externalAncestors.add(currentFieldCoords);
+                    }
+                    if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                        namedTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                        namedTypeData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
+                        shouldDefineSelectionSet = true;
+                        parentDatas.push(namedTypeData);
+                        return;
+                    }
+                },
+                leave() {
+                    externalAncestors.delete(fieldCoordsPath.pop() || '');
+                    fieldPath.pop();
+                },
+            },
+            InlineFragment: {
+                enter(node) {
+                    const parentData = parentDatas[currentDepth];
+                    const parentTypeName = parentData.name;
+                    const fieldCoordinates = fieldCoordsPath.length < 1 ? selectionSetParentData.name : fieldCoordsPath[fieldCoordsPath.length - 1];
+                    if (!node.typeCondition) {
+                        errorMessages.push((0, errors_1.inlineFragmentWithoutTypeConditionErrorMessage)(fieldSet, fieldCoordinates));
+                        return index_1.BREAK;
+                    }
+                    const typeConditionName = node.typeCondition.name.value;
+                    // It's possible to infinitely define fragments
+                    if (typeConditionName === parentTypeName) {
+                        parentDatas.push(parentData);
+                        shouldDefineSelectionSet = true;
+                        return;
+                    }
+                    if (!(0, utils_1.isKindAbstract)(parentData.kind)) {
+                        errorMessages.push((0, errors_1.invalidInlineFragmentTypeErrorMessage)(fieldSet, fieldCoordsPath, typeConditionName, parentTypeName));
+                        return index_1.BREAK;
+                    }
+                    const fragmentNamedTypeData = nf.parentDefinitionDataByTypeName.get(typeConditionName);
+                    if (!fragmentNamedTypeData) {
+                        errorMessages.push((0, errors_1.unknownInlineFragmentTypeConditionErrorMessage)(fieldSet, fieldCoordsPath, parentTypeName, typeConditionName));
+                        return index_1.BREAK;
+                    }
+                    shouldDefineSelectionSet = true;
+                    switch (fragmentNamedTypeData.kind) {
+                        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION: {
+                            if (!fragmentNamedTypeData.implementedInterfaceTypeNames.has(parentTypeName)) {
+                                break;
+                            }
+                            parentDatas.push(fragmentNamedTypeData);
+                            return;
+                        }
+                        case graphql_1.Kind.OBJECT_TYPE_DEFINITION: {
+                            const concreteTypeNames = nf.concreteTypeNamesByAbstractTypeName.get(parentTypeName);
+                            if (!concreteTypeNames || !concreteTypeNames.has(typeConditionName)) {
+                                break;
+                            }
+                            parentDatas.push(fragmentNamedTypeData);
+                            return;
+                        }
+                        case graphql_1.Kind.UNION_TYPE_DEFINITION: {
+                            parentDatas.push(fragmentNamedTypeData);
+                            return;
+                        }
+                        default: {
+                            errorMessages.push((0, errors_1.invalidInlineFragmentTypeConditionTypeErrorMessage)(fieldSet, fieldCoordsPath, parentTypeName, typeConditionName, (0, utils_5.kindToTypeString)(fragmentNamedTypeData.kind)));
+                            return index_1.BREAK;
+                        }
+                    }
+                    errorMessages.push((0, errors_1.invalidInlineFragmentTypeConditionErrorMessage)(fieldSet, fieldCoordsPath, typeConditionName, (0, utils_5.kindToTypeString)(parentData.kind), parentTypeName));
+                    return index_1.BREAK;
+                },
+            },
+            SelectionSet: {
+                enter() {
+                    if (!shouldDefineSelectionSet) {
+                        const parentData = parentDatas[currentDepth];
+                        if (parentData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
+                            // Should never happen
+                            errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName));
+                            return index_1.BREAK;
+                        }
+                        const fieldData = parentData.fieldDataByFieldName.get(lastFieldName);
+                        if (!fieldData) {
+                            errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentData.name, lastFieldName));
+                            return index_1.BREAK;
+                        }
+                        const fieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+                        // If the child is not found, it's a base scalar. Undefined types would have already been handled.
+                        const namedTypeData = nf.parentDefinitionDataByTypeName.get(fieldNamedTypeName);
+                        const childKind = namedTypeData ? namedTypeData.kind : graphql_1.Kind.SCALAR_TYPE_DEFINITION;
+                        errorMessages.push((0, errors_1.invalidSelectionSetDefinitionErrorMessage)(fieldSet, fieldCoordsPath, fieldNamedTypeName, (0, utils_5.kindToTypeString)(childKind)));
+                        return index_1.BREAK;
+                    }
+                    currentDepth += 1;
+                    shouldDefineSelectionSet = false;
+                    if (currentDepth < 0 || currentDepth >= parentDatas.length) {
+                        errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName));
+                        return index_1.BREAK;
+                    }
+                    definedFields.push(new Set());
+                },
+                leave() {
+                    if (shouldDefineSelectionSet) {
+                        const parentData = parentDatas[currentDepth + 1];
+                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, fieldCoordsPath, parentData.name, (0, utils_5.kindToTypeString)(parentData.kind)));
+                        shouldDefineSelectionSet = false;
+                    }
+                    // Empty selection sets would be a parse error, so it is unnecessary to handle them
+                    currentDepth -= 1;
+                    parentDatas.pop();
+                    definedFields.pop();
+                },
+            },
+        });
+        if (errorMessages.length > 0 || !hasConditionalField) {
+            return { errorMessages };
+        }
+        return {
+            configuration: { fieldName: directiveFieldName, selectionSet: (0, utils_2.getNormalizedFieldSet)(documentNode) },
+            errorMessages,
+        };
+    }
+    validateProvidesOrRequires(parentData, fieldSetByFieldName, isProvides) {
+        const allErrorMessages = [];
+        const configurations = [];
+        const parentTypeName = (0, utils_4.getParentTypeName)(parentData);
+        for (const [fieldName, fieldSet] of fieldSetByFieldName) {
+            /* It is possible to encounter a field before encountering the type definition.
+             Consequently, at that time, it is unknown whether the named type is an entity.
+             If it isn't, the @provides directive does not make sense and can be ignored.
+            */
+            const { fieldSetParentData, errorString } = this.getFieldSetParent(isProvides, parentData, fieldName, parentTypeName);
+            const fieldCoords = `${parentTypeName}.${fieldName}`;
+            if (errorString) {
+                allErrorMessages.push(errorString);
+                continue;
             }
-            if (keyFieldSet !== undefined) {
-                isUnresolvableByRawKeyFieldSet.set(keyFieldSet, isUnresolvable);
+            if (!fieldSetParentData) {
+                continue;
             }
+            const { errorMessages, configuration } = this.validateConditionalFieldSet(fieldSetParentData, fieldSet, fieldName, isProvides, parentTypeName);
+            /*
+             * It is possible to return no error messages nor configuration if the @provides or @requires directive is
+             * considered completely redundant, i.e.,:
+             * 1. All fields to which the directive refers are declared @external but are also key fields on an entity extension.
+             * 2. The subgraph is V1 and all fields to which the directive refers are not declared @external.
+             * In these cases, the fields are considered unconditionally provided.
+             * If all the fields to which the directive refers are unconditionally provided, the directive is redundant.
+             * For V2 subgraphs, this will propagate as an error; for V1 subgraphs, this will propagate as a warning.
+             * */
+            if (errorMessages.length > 0) {
+                allErrorMessages.push(` On field "${fieldCoords}":\n -` + errorMessages.join(string_constants_2.HYPHEN_JOIN));
+                continue;
+            }
+            if (configuration) {
+                configurations.push(configuration);
+            }
+        }
+        if (allErrorMessages.length > 0) {
+            this.errors.push((0, errors_1.invalidProvidesOrRequiresDirectivesError)((0, utils_2.getConditionalFieldSetDirectiveName)(isProvides), allErrorMessages));
+            return;
+        }
+        if (configurations.length > 0) {
+            return configurations;
         }
     }
     validateInterfaceImplementations(data) {
         if (data.implementedInterfaceTypeNames.size < 1) {
             return;
         }
-        const isParentInaccessible = data.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+        const isParentInaccessible = data.directivesByDirectiveName.has(string_constants_2.INACCESSIBLE);
         const implementationErrorsMap = new Map();
         const invalidImplementationTypeStringByTypeName = new Map();
         let doesInterfaceImplementItself = false;
@@ -1083,7 +1409,7 @@ class NormalizationFactory {
                 continue;
             }
             if (interfaceData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
-                invalidImplementationTypeStringByTypeName.set(interfaceData.name, (0, utils_3.kindToTypeString)(interfaceData.kind));
+                invalidImplementationTypeStringByTypeName.set(interfaceData.name, (0, utils_5.kindToTypeString)(interfaceData.kind));
                 continue;
             }
             if (data.name === interfaceData.name) {
@@ -1169,7 +1495,7 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.selfImplementationError)(data.name));
         }
         if (implementationErrorsMap.size > 0) {
-            this.errors.push((0, errors_1.invalidInterfaceImplementationError)(data.name, (0, utils_3.kindToTypeString)(data.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.invalidInterfaceImplementationError)(data.name, (0, utils_5.kindToTypeString)(data.kind), implementationErrorsMap));
         }
     }
     handleAuthenticatedDirective(data, parentTypeName) {
@@ -1181,7 +1507,7 @@ class NormalizationFactory {
         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 parentAuthorizationData = (0, utils_5.getValueOrDefault)(this.authorizationDataByParentTypeName, parentTypeName, () => (0, utils_3.newAuthorizationData)(parentTypeName));
         (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, data.node).requiresAuthentication = true;
     }
     handleOverrideDirective({ data, directiveCoords, errorMessages, targetSubgraphName }) {
@@ -1189,8 +1515,8 @@ class NormalizationFactory {
             errorMessages.push((0, errors_1.equivalentSourceAndTargetOverrideErrorMessage)(targetSubgraphName, directiveCoords));
             return;
         }
-        const overrideDataForSubgraph = (0, utils_3.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-        (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName || data.originalParentTypeName, () => new Set()).add(data.name);
+        const overrideDataForSubgraph = (0, utils_5.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
+        (0, utils_5.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName || data.originalParentTypeName, () => new Set()).add(data.name);
     }
     handleRequiresScopesDirective({ directiveCoords, orScopes, requiredScopes }) {
         if (orScopes.length > utils_3.maxOrScopes) {
@@ -1209,19 +1535,19 @@ class NormalizationFactory {
     }
     getKafkaPublishConfiguration(directive, argumentDataByArgumentName, errorMessages) {
         const topics = [];
-        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
-                case string_constants_1.TOPIC: {
+                case string_constants_2.TOPIC: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
-                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_1.TOPIC));
+                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_2.TOPIC));
                         continue;
                     }
                     (0, utils_2.validateArgumentTemplateReferences)(argumentNode.value.value, argumentDataByArgumentName, errorMessages);
                     topics.push(argumentNode.value.value);
                     break;
                 }
-                case string_constants_1.PROVIDER_ID: {
+                case string_constants_2.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
                         errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
@@ -1234,21 +1560,21 @@ class NormalizationFactory {
         if (errorMessages.length > 0) {
             return;
         }
-        return { fieldName: this.childName, providerId, providerType: string_constants_1.PROVIDER_TYPE_KAFKA, topics, type: string_constants_1.PUBLISH };
+        return { fieldName: this.childName, providerId, providerType: string_constants_2.PROVIDER_TYPE_KAFKA, topics, type: string_constants_2.PUBLISH };
     }
     getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages) {
         const topics = [];
-        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
-                case string_constants_1.TOPICS: {
+                case string_constants_2.TOPICS: {
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
-                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_1.TOPICS));
+                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_2.TOPICS));
                         continue;
                     }
                     for (const value of argumentNode.value.values) {
                         if (value.kind !== graphql_1.Kind.STRING || value.value.length < 1) {
-                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_1.TOPICS));
+                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_2.TOPICS));
                             break;
                         }
                         (0, utils_2.validateArgumentTemplateReferences)(value.value, argumentDataByArgumentName, errorMessages);
@@ -1256,7 +1582,7 @@ class NormalizationFactory {
                     }
                     break;
                 }
-                case string_constants_1.PROVIDER_ID: {
+                case string_constants_2.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
                         errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
@@ -1272,26 +1598,26 @@ class NormalizationFactory {
         return {
             fieldName: this.childName,
             providerId,
-            providerType: string_constants_1.PROVIDER_TYPE_KAFKA,
+            providerType: string_constants_2.PROVIDER_TYPE_KAFKA,
             topics: topics,
-            type: string_constants_1.SUBSCRIBE,
+            type: string_constants_2.SUBSCRIBE,
         };
     }
     getNatsPublishAndRequestConfiguration(eventType, directive, argumentDataByArgumentName, errorMessages) {
         const subjects = [];
-        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
-                case string_constants_1.SUBJECT: {
+                case string_constants_2.SUBJECT: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
-                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_1.SUBJECT));
+                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_2.SUBJECT));
                         continue;
                     }
                     (0, utils_2.validateArgumentTemplateReferences)(argumentNode.value.value, argumentDataByArgumentName, errorMessages);
                     subjects.push(argumentNode.value.value);
                     break;
                 }
-                case string_constants_1.PROVIDER_ID: {
+                case string_constants_2.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
                         errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
@@ -1304,24 +1630,24 @@ class NormalizationFactory {
         if (errorMessages.length > 0) {
             return;
         }
-        return { fieldName: this.childName, providerId, providerType: string_constants_1.PROVIDER_TYPE_NATS, subjects, type: eventType };
+        return { fieldName: this.childName, providerId, providerType: string_constants_2.PROVIDER_TYPE_NATS, subjects, type: eventType };
     }
     getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages) {
         const subjects = [];
-        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         let consumerInactiveThreshold = integer_constants_1.DEFAULT_CONSUMER_INACTIVE_THRESHOLD;
         let consumerName = '';
         let streamName = '';
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
-                case string_constants_1.SUBJECTS: {
+                case string_constants_2.SUBJECTS: {
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
                         // errorMessages.push(invalidEventSubjectsErrorMessage(SUBJECTS));
                         continue;
                     }
                     for (const value of argumentNode.value.values) {
                         if (value.kind !== graphql_1.Kind.STRING || value.value.length < 1) {
-                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_1.SUBJECTS));
+                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_2.SUBJECTS));
                             break;
                         }
                         (0, utils_2.validateArgumentTemplateReferences)(value.value, argumentDataByArgumentName, errorMessages);
@@ -1329,7 +1655,7 @@ class NormalizationFactory {
                     }
                     break;
                 }
-                case string_constants_1.PROVIDER_ID: {
+                case string_constants_2.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
                         errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
@@ -1337,7 +1663,7 @@ class NormalizationFactory {
                     providerId = argumentNode.value.value;
                     break;
                 }
-                case string_constants_1.STREAM_CONFIGURATION: {
+                case string_constants_2.STREAM_CONFIGURATION: {
                     this.usesEdfsNatsStreamConfiguration = true;
                     if (argumentNode.value.kind !== graphql_1.Kind.OBJECT || argumentNode.value.fields.length < 1) {
                         errorMessages.push(errors_1.invalidNatsStreamInputErrorMessage);
@@ -1346,7 +1672,7 @@ class NormalizationFactory {
                     let isValid = true;
                     const invalidFieldNames = new Set();
                     const allowedFieldNames = new Set(string_constants_1.STREAM_CONFIGURATION_FIELD_NAMES);
-                    const missingRequiredFieldNames = new Set([string_constants_1.CONSUMER_NAME, string_constants_1.STREAM_NAME]);
+                    const missingRequiredFieldNames = new Set([string_constants_2.CONSUMER_NAME, string_constants_2.STREAM_NAME]);
                     const duplicateFieldNames = new Set();
                     const invalidRequiredFieldNames = new Set();
                     for (const field of argumentNode.value.fields) {
@@ -1368,7 +1694,7 @@ class NormalizationFactory {
                             missingRequiredFieldNames.delete(fieldName);
                         }
                         switch (fieldName) {
-                            case string_constants_1.CONSUMER_NAME:
+                            case string_constants_2.CONSUMER_NAME:
                                 if (field.value.kind != graphql_1.Kind.STRING || field.value.value.length < 1) {
                                     invalidRequiredFieldNames.add(fieldName);
                                     isValid = false;
@@ -1376,7 +1702,7 @@ class NormalizationFactory {
                                 }
                                 consumerName = field.value.value;
                                 break;
-                            case string_constants_1.STREAM_NAME:
+                            case string_constants_2.STREAM_NAME:
                                 if (field.value.kind != graphql_1.Kind.STRING || field.value.value.length < 1) {
                                     invalidRequiredFieldNames.add(fieldName);
                                     isValid = false;
@@ -1384,9 +1710,9 @@ class NormalizationFactory {
                                 }
                                 streamName = field.value.value;
                                 break;
-                            case string_constants_1.CONSUMER_INACTIVE_THRESHOLD:
+                            case string_constants_2.CONSUMER_INACTIVE_THRESHOLD:
                                 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));
+                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(field.value), 'edfs__NatsStreamConfiguration', `consumerInactiveThreshold`, string_constants_2.INT_SCALAR));
                                     isValid = false;
                                     continue;
                                 }
@@ -1395,7 +1721,7 @@ class NormalizationFactory {
                                     consumerInactiveThreshold = parseInt(field.value.value, 10);
                                 }
                                 catch (e) {
-                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(field.value), 'edfs__NatsStreamConfiguration', `consumerInactiveThreshold`, string_constants_1.INT_SCALAR));
+                                    errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(field.value), 'edfs__NatsStreamConfiguration', `consumerInactiveThreshold`, string_constants_2.INT_SCALAR));
                                     isValid = false;
                                 }
                                 break;
@@ -1414,16 +1740,16 @@ class NormalizationFactory {
             consumerInactiveThreshold = integer_constants_1.DEFAULT_CONSUMER_INACTIVE_THRESHOLD;
             this.warnings.push((0, warnings_1.consumerInactiveThresholdInvalidValueWarning)(this.subgraphName, `The value has been set to ${integer_constants_1.DEFAULT_CONSUMER_INACTIVE_THRESHOLD}.`));
         }
-        else if (consumerInactiveThreshold > integer_constants_1.MAX_INT32) {
+        else if (consumerInactiveThreshold > integer_constants_2.MAX_INT32) {
             consumerInactiveThreshold = 0;
             this.warnings.push((0, warnings_1.consumerInactiveThresholdInvalidValueWarning)(this.subgraphName, 'The value has been set to 0. This means the consumer will remain indefinitely active until its manual deletion.'));
         }
         return {
             fieldName: this.childName,
             providerId,
-            providerType: string_constants_1.PROVIDER_TYPE_NATS,
+            providerType: string_constants_2.PROVIDER_TYPE_NATS,
             subjects,
-            type: string_constants_1.SUBSCRIBE,
+            type: string_constants_2.SUBSCRIBE,
             ...(consumerName && streamName
                 ? {
                     streamConfiguration: {
@@ -1443,7 +1769,7 @@ class NormalizationFactory {
         const fieldPath = `${parentTypeName}.${node.name.value}`;
         const isSubscription = this.getOperationTypeNodeForRootTypeName(parentTypeName) === graphql_1.OperationTypeNode.SUBSCRIPTION;
         for (const directiveNode of node.directives) {
-            if (directiveNode.name.value !== string_constants_1.SUBSCRIPTION_FILTER) {
+            if (directiveNode.name.value !== string_constants_2.SUBSCRIPTION_FILTER) {
                 continue;
             }
             if (!isSubscription) {
@@ -1462,21 +1788,21 @@ class NormalizationFactory {
             const errorMessages = [];
             let eventConfiguration;
             switch (directive.name.value) {
-                case string_constants_1.EDFS_KAFKA_PUBLISH:
+                case string_constants_2.EDFS_KAFKA_PUBLISH:
                     eventConfiguration = this.getKafkaPublishConfiguration(directive, argumentDataByArgumentName, errorMessages);
                     break;
-                case string_constants_1.EDFS_KAFKA_SUBSCRIBE:
+                case string_constants_2.EDFS_KAFKA_SUBSCRIBE:
                     eventConfiguration = this.getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages);
                     break;
-                case string_constants_1.EDFS_NATS_PUBLISH: {
-                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_1.PUBLISH, directive, argumentDataByArgumentName, errorMessages);
+                case string_constants_2.EDFS_NATS_PUBLISH: {
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.PUBLISH, directive, argumentDataByArgumentName, errorMessages);
                     break;
                 }
-                case string_constants_1.EDFS_NATS_REQUEST: {
-                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_1.REQUEST, directive, argumentDataByArgumentName, errorMessages);
+                case string_constants_2.EDFS_NATS_REQUEST: {
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.REQUEST, directive, argumentDataByArgumentName, errorMessages);
                     break;
                 }
-                case string_constants_1.EDFS_NATS_SUBSCRIBE: {
+                case string_constants_2.EDFS_NATS_SUBSCRIBE: {
                     eventConfiguration = this.getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages);
                     break;
                 }
@@ -1491,17 +1817,17 @@ class NormalizationFactory {
             if (!eventConfiguration) {
                 continue;
             }
-            (0, utils_3.getValueOrDefault)(this.eventsConfigurations, this.renamedParentTypeName || this.originalParentTypeName, () => []).push(eventConfiguration);
+            (0, utils_5.getValueOrDefault)(this.eventsConfigurations, this.renamedParentTypeName || this.originalParentTypeName, () => []).push(eventConfiguration);
         }
     }
     getValidEventsDirectiveNamesForOperationTypeNode(operationTypeNode) {
         switch (operationTypeNode) {
             case graphql_1.OperationTypeNode.MUTATION:
-                return new Set([string_constants_1.EDFS_KAFKA_PUBLISH, string_constants_1.EDFS_NATS_PUBLISH, string_constants_1.EDFS_NATS_REQUEST]);
+                return new Set([string_constants_2.EDFS_KAFKA_PUBLISH, string_constants_2.EDFS_NATS_PUBLISH, string_constants_2.EDFS_NATS_REQUEST]);
             case graphql_1.OperationTypeNode.QUERY:
-                return new Set([string_constants_1.EDFS_NATS_REQUEST]);
+                return new Set([string_constants_2.EDFS_NATS_REQUEST]);
             case graphql_1.OperationTypeNode.SUBSCRIPTION:
-                return new Set([string_constants_1.EDFS_KAFKA_SUBSCRIBE, string_constants_1.EDFS_NATS_SUBSCRIBE]);
+                return new Set([string_constants_2.EDFS_KAFKA_SUBSCRIBE, string_constants_2.EDFS_NATS_SUBSCRIBE]);
         }
     }
     getOperationTypeNodeForRootTypeName(parentTypeName) {
@@ -1510,11 +1836,11 @@ class NormalizationFactory {
             return operationTypeNode;
         }
         switch (parentTypeName) {
-            case string_constants_1.MUTATION:
+            case string_constants_2.MUTATION:
                 return graphql_1.OperationTypeNode.MUTATION;
-            case string_constants_1.QUERY:
+            case string_constants_2.QUERY:
                 return graphql_1.OperationTypeNode.QUERY;
-            case string_constants_1.SUBSCRIPTION:
+            case string_constants_2.SUBSCRIPTION:
                 return graphql_1.OperationTypeNode.SUBSCRIPTION;
             default:
                 return;
@@ -1550,7 +1876,7 @@ class NormalizationFactory {
             }
             if (operationTypeNode === graphql_1.OperationTypeNode.MUTATION) {
                 const typeString = (0, merge_1.printTypeNode)(fieldData.type);
-                if (typeString !== string_constants_1.NON_NULLABLE_EDFS_PUBLISH_EVENT_RESULT) {
+                if (typeString !== string_constants_2.NON_NULLABLE_EDFS_PUBLISH_EVENT_RESULT) {
                     invalidResponseTypeNameByMutationPath.set(fieldPath, typeString);
                 }
                 continue;
@@ -1572,22 +1898,22 @@ class NormalizationFactory {
         }
     }
     validateEventDrivenKeyDefinition(typeName, invalidKeyFieldSetsByEntityTypeName) {
-        const keyFieldSetData = this.keyFieldSetDataByTypeName.get(typeName);
-        if (!keyFieldSetData) {
+        const keyFieldSetDataByFieldSet = this.keyFieldSetDatasByTypeName.get(typeName);
+        if (!keyFieldSetDataByFieldSet) {
             return;
         }
-        for (const [keyFieldSet, isUnresolvable] of keyFieldSetData.isUnresolvableByKeyFieldSet) {
+        for (const [keyFieldSet, { isUnresolvable }] of keyFieldSetDataByFieldSet) {
             if (isUnresolvable) {
                 continue;
             }
-            (0, utils_3.getValueOrDefault)(invalidKeyFieldSetsByEntityTypeName, typeName, () => []).push(keyFieldSet);
+            (0, utils_5.getValueOrDefault)(invalidKeyFieldSetsByEntityTypeName, typeName, () => []).push(keyFieldSet);
         }
     }
     validateEventDrivenObjectFields(fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath) {
         for (const [fieldName, fieldData] of fieldDataByFieldName) {
             const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
             if (keyFieldNames.has(fieldName)) {
-                if (!fieldData.isExternalBySubgraphName.get(this.subgraphName)) {
+                if (!fieldData.externalFieldDataBySubgraphName.get(this.subgraphName)?.isDefinedExternal) {
                     nonExternalKeyFieldNameByFieldPath.set(fieldPath, fieldName);
                 }
                 continue;
@@ -1596,7 +1922,7 @@ class NormalizationFactory {
         }
     }
     isEdfsPublishResultValid() {
-        const data = this.parentDefinitionDataByTypeName.get(string_constants_1.EDFS_PUBLISH_RESULT);
+        const data = this.parentDefinitionDataByTypeName.get(string_constants_2.EDFS_PUBLISH_RESULT);
         if (!data) {
             return true;
         }
@@ -1610,10 +1936,10 @@ class NormalizationFactory {
             if (fieldData.argumentDataByArgumentName.size > 0) {
                 return false;
             }
-            if (fieldName !== string_constants_1.SUCCESS) {
+            if (fieldName !== string_constants_2.SUCCESS) {
                 return false;
             }
-            if ((0, merge_1.printTypeNode)(fieldData.type) !== string_constants_1.NON_NULLABLE_BOOLEAN) {
+            if ((0, merge_1.printTypeNode)(fieldData.type) !== string_constants_2.NON_NULLABLE_BOOLEAN) {
                 return false;
             }
         }
@@ -1628,8 +1954,8 @@ class NormalizationFactory {
         }
         for (const [inputValueName, inputValueData] of streamConfigurationInputData.inputValueDataByValueName) {
             switch (inputValueName) {
-                case string_constants_1.CONSUMER_INACTIVE_THRESHOLD: {
-                    if ((0, merge_1.printTypeNode)(inputValueData.type) !== string_constants_1.NON_NULLABLE_INT) {
+                case string_constants_2.CONSUMER_INACTIVE_THRESHOLD: {
+                    if ((0, merge_1.printTypeNode)(inputValueData.type) !== string_constants_2.NON_NULLABLE_INT) {
                         return false;
                     }
                     if (!inputValueData.defaultValue ||
@@ -1639,10 +1965,10 @@ class NormalizationFactory {
                     }
                     break;
                 }
-                case string_constants_1.CONSUMER_NAME:
+                case string_constants_2.CONSUMER_NAME:
                 // intentional fallthrough
-                case string_constants_1.STREAM_NAME: {
-                    if ((0, merge_1.printTypeNode)(inputValueData.type) !== string_constants_1.NON_NULLABLE_STRING) {
+                case string_constants_2.STREAM_NAME: {
+                    if ((0, merge_1.printTypeNode)(inputValueData.type) !== string_constants_2.NON_NULLABLE_STRING) {
                         return false;
                     }
                     break;
@@ -1666,7 +1992,7 @@ class NormalizationFactory {
         const invalidObjectTypeNames = new Set();
         for (const [typeName, data] of this.parentDefinitionDataByTypeName) {
             // validate edfs__PublishResult and edfs__NatsStreamConfiguration separately
-            if (typeName === string_constants_1.EDFS_PUBLISH_RESULT || typeName === string_constants_1.EDFS_NATS_STREAM_CONFIGURATION) {
+            if (typeName === string_constants_2.EDFS_PUBLISH_RESULT || typeName === string_constants_2.EDFS_NATS_STREAM_CONFIGURATION) {
                 continue;
             }
             if (data.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
@@ -1687,18 +2013,18 @@ class NormalizationFactory {
         if (!this.isEdfsPublishResultValid()) {
             errorMessages.push(errors_1.invalidEdfsPublishResultObjectErrorMessage);
         }
-        if (this.edfsDirectiveReferences.has(string_constants_1.EDFS_NATS_SUBSCRIBE)) {
-            const streamConfigurationInputData = this.parentDefinitionDataByTypeName.get(string_constants_1.EDFS_NATS_STREAM_CONFIGURATION);
+        if (this.edfsDirectiveReferences.has(string_constants_2.EDFS_NATS_SUBSCRIBE)) {
+            const streamConfigurationInputData = this.parentDefinitionDataByTypeName.get(string_constants_2.EDFS_NATS_STREAM_CONFIGURATION);
             if (streamConfigurationInputData &&
                 this.usesEdfsNatsStreamConfiguration &&
                 !this.isNatsStreamConfigurationInputObjectValid(streamConfigurationInputData)) {
                 errorMessages.push(errors_1.invalidNatsStreamConfigurationDefinitionErrorMessage);
             }
             // always add the correct definition to the schema regardless
-            this.parentDefinitionDataByTypeName.delete(string_constants_1.EDFS_NATS_STREAM_CONFIGURATION);
+            this.parentDefinitionDataByTypeName.delete(string_constants_2.EDFS_NATS_STREAM_CONFIGURATION);
             definitions.push(constants_1.EDFS_NATS_STREAM_CONFIGURATION_DEFINITION);
         }
-        if (this.referencedDirectiveNames.has(string_constants_1.LINK)) {
+        if (this.referencedDirectiveNames.has(string_constants_2.LINK)) {
             definitions.push(constants_1.LINK_DEFINITION);
             definitions.push(constants_1.LINK_IMPORT_DEFINITION);
             definitions.push(constants_1.LINK_PURPOSE_DEFINITION);
@@ -1744,7 +2070,7 @@ class NormalizationFactory {
                 continue;
             }
             if (memberData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                invalidMembers.push(`"${memberName}", which is type "${(0, utils_3.kindToTypeString)(memberData.kind)}"`);
+                invalidMembers.push(`"${memberName}", which is type "${(0, utils_5.kindToTypeString)(memberData.kind)}"`);
             }
         }
         if (invalidMembers.length > 0) {
@@ -1758,26 +2084,24 @@ class NormalizationFactory {
         const unionTypeName = node.name.value;
         for (const member of node.types) {
             const memberTypeName = member.name.value;
-            (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, unionTypeName, () => new Set()).add(memberTypeName);
+            (0, utils_5.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, unionTypeName, () => new Set()).add(memberTypeName);
             this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(unionTypeName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(memberTypeName), memberTypeName, true);
         }
     }
-    validateAndAddKeyToConfiguration(parentData, keyFieldSetData) {
-        const configurationData = (0, utils_3.getOrThrowError)(this.configurationDataByParentTypeName, (0, utils_4.getParentTypeName)(parentData), 'configurationDataByParentTypeName');
-        const keys = (0, utils_2.validateKeyFieldSets)(this, parentData, keyFieldSetData.isUnresolvableByKeyFieldSet, configurationData.fieldNames);
-        if (keys) {
-            configurationData.keys = keys;
-        }
-    }
-    validateAndAddKeysToConfiguration() {
-        for (const [parentTypeName, keyFieldSetData] of this.keyFieldSetDataByTypeName) {
-            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName);
+    addValidKeyFieldSetConfigurations() {
+        for (const [entityTypeName, keyFieldSetDataByFieldSet] of this.keyFieldSetDatasByTypeName) {
+            const parentData = this.parentDefinitionDataByTypeName.get(entityTypeName);
             if (!parentData ||
                 (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
-                this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
+                this.errors.push((0, errors_1.undefinedCompositeOutputTypeError)(entityTypeName));
                 continue;
             }
-            this.validateAndAddKeyToConfiguration(parentData, keyFieldSetData);
+            const typeName = (0, utils_4.getParentTypeName)(parentData);
+            const configurationData = (0, utils_5.getValueOrDefault)(this.configurationDataByTypeName, typeName, () => (0, utils_6.newConfigurationData)(true, typeName));
+            const keys = (0, utils_2.validateKeyFieldSets)(this, parentData, keyFieldSetDataByFieldSet, configurationData.fieldNames);
+            if (keys) {
+                configurationData.keys = keys;
+            }
         }
     }
     getValidFlattenedDirectiveArray(directivesByDirectiveName, directiveCoords) {
@@ -1788,7 +2112,7 @@ class NormalizationFactory {
                 continue;
             }
             if (!directiveDefinition.isRepeatable && directiveNodes.length > 1) {
-                const handledDirectiveNames = (0, utils_3.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
+                const handledDirectiveNames = (0, utils_5.getValueOrDefault)(this.invalidRepeatedDirectiveNameByCoords, directiveCoords, () => new Set());
                 if (!handledDirectiveNames.has(directiveName)) {
                     handledDirectiveNames.add(directiveName);
                     this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, directiveCoords, '1st', [
@@ -1797,7 +2121,7 @@ class NormalizationFactory {
                 }
                 continue;
             }
-            if (directiveName !== string_constants_1.KEY) {
+            if (directiveName !== string_constants_2.KEY) {
                 flattenedArray.push(...directiveNodes);
                 continue;
             }
@@ -1859,6 +2183,179 @@ class NormalizationFactory {
         unionDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(unionDefinitionData.memberByMemberTypeName);
         return unionDefinitionData.node;
     }
+    evaluateExternalKeyFields() {
+        const invalidTypeNames = [];
+        for (const [entityTypeName, keyFieldSetDataByFieldSet] of this.keyFieldSetDatasByTypeName) {
+            const entityParentData = this.parentDefinitionDataByTypeName.get(entityTypeName);
+            // The parent data should always exist.
+            if (!entityParentData ||
+                (entityParentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                    entityParentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
+                // If somehow the parent data does not exist, prevent the same error occurring by removing that type from the map.
+                invalidTypeNames.push(entityTypeName);
+                this.errors.push((0, errors_1.undefinedCompositeOutputTypeError)(entityTypeName));
+                continue;
+            }
+            const nf = this;
+            for (const keyFieldSetData of keyFieldSetDataByFieldSet.values()) {
+                const parentDatas = [entityParentData];
+                // Entity extension fields are effectively never @external, so propagate a warning.
+                const externalExtensionFieldCoordsByRawFieldSet = new Map();
+                let currentDepth = -1;
+                let shouldDefineSelectionSet = true;
+                (0, index_1.visit)(keyFieldSetData.documentNode, {
+                    Argument: {
+                        enter() {
+                            return index_1.BREAK;
+                        },
+                    },
+                    Field: {
+                        enter(node) {
+                            const parentData = parentDatas[currentDepth];
+                            const parentTypeName = parentData.name;
+                            // If a composite type was just visited, a selection set should have been entered
+                            if (shouldDefineSelectionSet) {
+                                return index_1.BREAK;
+                            }
+                            const fieldName = node.name.value;
+                            const fieldCoords = `${parentTypeName}.${fieldName}`;
+                            // If a field declared @external is a key field, it is valid use of @external.
+                            nf.unvalidatedExternalFieldCoords.delete(fieldCoords);
+                            const fieldData = parentData.fieldDataByFieldName.get(fieldName);
+                            // undefined if the field does not exist on the parent
+                            if (!fieldData || fieldData.argumentDataByArgumentName.size) {
+                                return index_1.BREAK;
+                            }
+                            // Fields that form part of an entity key are intrinsically shareable
+                            fieldData.isShareableBySubgraphName.set(nf.subgraphName, true);
+                            /* !!! IMPORTANT NOTE REGARDING INCONSISTENT APOLLO BEHAVIOUR !!!
+                             * V1 entities with "@extends" may define unique nested key fields as @external without restriction.
+                             * However, V1 entity extensions (with the "extend" keyword) cannot do this.
+                             * Instead, an error is returned stating that there must be a non-external definition of the field.
+                             * This inconsistency in behaviour appears to be a bug.
+                             * It doesn't make much sense to enforce "origin fields" only sometimes (or ever, honestly).
+                             * Consequently, a decision was made not ever to enforce meaningless origin fields for extensions.
+                             *
+                             * In the event the nested key field is not unique, the error may propagate as a field resolvability
+                             * error, e.g., unable to use the nested @external key field to satisfy a field set in another subgraph.
+                             *
+                             * In addition, the nested key field of a V2 entity extension (either "@extends" or "extend" keyword)
+                             * are considered unconditionally provided regardless of the presence of "@external".
+                             *
+                             * However, if the subgraph is an EDG, the @external state should be kept regardless of extension.
+                             * */
+                            const externalFieldData = fieldData.externalFieldDataBySubgraphName.get(nf.subgraphName);
+                            if (nf.edfsDirectiveReferences.size < 1 &&
+                                externalFieldData &&
+                                externalFieldData.isDefinedExternal &&
+                                !externalFieldData.isUnconditionallyProvided) {
+                                /*
+                                 * The key field is unconditionally provided if all the following are true:
+                                 * 1. The root entity is an extension type.
+                                 * 2. The field is also a key field for the parent entity.
+                                 */
+                                if (entityParentData.extensionType !== types_1.ExtensionType.NONE) {
+                                    externalFieldData.isUnconditionallyProvided = true;
+                                    (0, utils_5.getValueOrDefault)(externalExtensionFieldCoordsByRawFieldSet, keyFieldSetData.rawFieldSet, () => new Set()).add(fieldCoords);
+                                }
+                            }
+                            (0, utils_5.getValueOrDefault)(nf.keyFieldNamesByParentTypeName, parentTypeName, () => new Set()).add(fieldName);
+                            const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+                            // The base scalars are not in the parents map
+                            if (constants_1.BASE_SCALARS.has(namedTypeName)) {
+                                return;
+                            }
+                            // The child could itself be a parent
+                            const namedTypeData = nf.parentDefinitionDataByTypeName.get(namedTypeName);
+                            if (!namedTypeData) {
+                                return index_1.BREAK;
+                            }
+                            if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                                shouldDefineSelectionSet = true;
+                                parentDatas.push(namedTypeData);
+                                return;
+                            }
+                            // interfaces and unions are invalid in a key directive
+                            if ((0, utils_1.isKindAbstract)(namedTypeData.kind)) {
+                                return index_1.BREAK;
+                            }
+                        },
+                    },
+                    InlineFragment: {
+                        enter() {
+                            return index_1.BREAK;
+                        },
+                    },
+                    SelectionSet: {
+                        enter() {
+                            if (!shouldDefineSelectionSet) {
+                                return index_1.BREAK;
+                            }
+                            currentDepth += 1;
+                            shouldDefineSelectionSet = false;
+                            if (currentDepth < 0 || currentDepth >= parentDatas.length) {
+                                return index_1.BREAK;
+                            }
+                        },
+                        leave() {
+                            if (shouldDefineSelectionSet) {
+                                shouldDefineSelectionSet = false;
+                            }
+                            // Empty selection sets would be a parse error, so it is unnecessary to handle them
+                            currentDepth -= 1;
+                            parentDatas.pop();
+                        },
+                    },
+                });
+                if (externalExtensionFieldCoordsByRawFieldSet.size < 1) {
+                    continue;
+                }
+                for (const [rawFieldSet, fieldCoords] of externalExtensionFieldCoordsByRawFieldSet) {
+                    this.warnings.push((0, warnings_1.externalEntityExtensionKeyFieldWarning)(entityParentData.name, rawFieldSet, [...fieldCoords], this.subgraphName));
+                }
+            }
+        }
+        for (const invalidTypeName of invalidTypeNames) {
+            this.keyFieldSetDatasByTypeName.delete(invalidTypeName);
+        }
+    }
+    addValidConditionalFieldSetConfigurations() {
+        for (const [typeName, fieldSetData] of this.fieldSetDataByTypeName) {
+            const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+            if (!parentData ||
+                (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
+                this.errors.push((0, errors_1.undefinedCompositeOutputTypeError)(typeName));
+                continue;
+            }
+            const parentTypeName = (0, utils_4.getParentTypeName)(parentData);
+            const configurationData = (0, utils_5.getValueOrDefault)(this.configurationDataByTypeName, parentTypeName, () => (0, utils_6.newConfigurationData)(false, parentTypeName));
+            const provides = this.validateProvidesOrRequires(parentData, fieldSetData.provides, true);
+            if (provides) {
+                configurationData.provides = provides;
+            }
+            const requires = this.validateProvidesOrRequires(parentData, fieldSetData.requires, false);
+            if (requires) {
+                configurationData.requires = requires;
+            }
+        }
+    }
+    addFieldNamesToConfigurationData(fieldDataByFieldName, configurationData) {
+        const externalFieldNames = new Set();
+        for (const [fieldName, fieldData] of fieldDataByFieldName) {
+            const externalFieldData = fieldData.externalFieldDataBySubgraphName.get(this.subgraphName);
+            if (!externalFieldData || externalFieldData.isUnconditionallyProvided) {
+                configurationData.fieldNames.add(fieldName);
+                continue;
+            }
+            externalFieldNames.add(fieldName);
+            if (this.edfsDirectiveReferences.size > 0) {
+                configurationData.fieldNames.add(fieldName);
+            }
+        }
+        if (externalFieldNames.size > 0) {
+            configurationData.externalFieldNames = externalFieldNames;
+        }
+    }
     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,
@@ -1866,7 +2363,7 @@ 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);
+        this.validateDirectives(this.schemaData, string_constants_2.SCHEMA);
         for (const [parentTypeName, parentData] of this.parentDefinitionDataByTypeName) {
             this.validateDirectives(parentData, parentTypeName);
         }
@@ -1878,7 +2375,7 @@ class NormalizationFactory {
             }
             const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(interfaceTypeName);
             for (const concreteTypeName of concreteTypeNames || []) {
-                const concreteAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_3.newAuthorizationData)(concreteTypeName));
+                const concreteAuthorizationData = (0, utils_5.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_3.newAuthorizationData)(concreteTypeName));
                 for (const [fieldName, interfaceFieldAuthorizationData,] of interfaceAuthorizationData.fieldAuthorizationDataByFieldName) {
                     if (!(0, utils_3.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, interfaceFieldAuthorizationData)) {
                         this.invalidOrScopesHostPaths.add(`${concreteTypeName}.${fieldName}`);
@@ -1923,16 +2420,16 @@ class NormalizationFactory {
             definitions.push(directiveDefinition);
         }
         // subscriptionFilter is temporarily valid only in an EDG
-        if (this.edfsDirectiveReferences.size > 0 && this.referencedDirectiveNames.has(string_constants_1.SUBSCRIPTION_FILTER)) {
+        if (this.edfsDirectiveReferences.size > 0 && this.referencedDirectiveNames.has(string_constants_2.SUBSCRIPTION_FILTER)) {
             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)) {
+        if (this.referencedDirectiveNames.has(string_constants_2.CONFIGURE_DESCRIPTION)) {
             definitions.push(constants_1.CONFIGURE_DESCRIPTION_DEFINITION);
         }
-        if (this.referencedDirectiveNames.has(string_constants_1.CONFIGURE_CHILD_DESCRIPTIONS)) {
+        if (this.referencedDirectiveNames.has(string_constants_2.CONFIGURE_CHILD_DESCRIPTIONS)) {
             definitions.push(constants_1.CONFIGURE_CHILD_DESCRIPTIONS_DEFINITION);
         }
         for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
@@ -1947,9 +2444,11 @@ class NormalizationFactory {
          * */
         for (const data of this.invalidConfigureDescriptionNodeDatas) {
             if (!data.description) {
-                this.errors.push((0, errors_1.configureDescriptionNoDescriptionError)((0, utils_3.kindToTypeString)(data.kind), data.name));
+                this.errors.push((0, errors_1.configureDescriptionNoDescriptionError)((0, utils_5.kindToTypeString)(data.kind), data.name));
             }
         }
+        // Check all key field sets for @external fields to assess whether they are conditional
+        this.evaluateExternalKeyFields();
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
             switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
@@ -1973,16 +2472,20 @@ class NormalizationFactory {
                     const isEntity = this.entityDataByTypeName.has(parentTypeName);
                     const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
                     const isObject = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION;
+                    if (this.isSubgraphVersionTwo && parentDefinitionData.extensionType === types_1.ExtensionType.EXTENDS) {
+                        // @extends is essentially ignored in V2. It was only propagated to handle @external key fields.
+                        parentDefinitionData.extensionType = types_1.ExtensionType.NONE;
+                    }
                     if (operationTypeNode) {
-                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
-                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
+                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_2.SERVICE_FIELD);
+                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_2.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) {
-                            if (!isObject && fieldData.isExternalBySubgraphName.get(this.subgraphName)) {
+                            if (!isObject && fieldData.externalFieldDataBySubgraphName.get(this.subgraphName)?.isDefinedExternal) {
                                 externalInterfaceFieldNames.push(fieldName);
                             }
                             // Arguments can only be fully validated once all parents types are known
@@ -1995,18 +2498,15 @@ class NormalizationFactory {
                                 : this.warnings.push((0, warnings_1.externalInterfaceFieldsWarning)(this.subgraphName, parentTypeName, externalInterfaceFieldNames));
                         }
                     }
-                    const newParentTypeName = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION
-                        ? parentDefinitionData.renamedTypeName || parentTypeName
-                        : parentTypeName;
-                    const configurationData = {
-                        fieldNames: new Set(),
-                        isRootNode: isEntity,
-                        typeName: newParentTypeName,
-                    };
+                    const newParentTypeName = (0, utils_4.getParentTypeName)(parentDefinitionData);
+                    const configurationData = (0, utils_5.getValueOrDefault)(this.configurationDataByTypeName, newParentTypeName, () => (0, utils_6.newConfigurationData)(isEntity, parentTypeName));
                     const entityInterfaceData = this.entityInterfaceDataByTypeName.get(parentTypeName);
                     if (entityInterfaceData) {
                         entityInterfaceData.fieldDatas = (0, utils_3.fieldDatasToSimpleFieldDatas)(parentDefinitionData.fieldDataByFieldName.values());
-                        entityInterfaceData.concreteTypeNames = (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, parentTypeName, () => new Set());
+                        const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(parentTypeName);
+                        if (concreteTypeNames) {
+                            (0, utils_5.addIterableValuesToSet)(concreteTypeNames, entityInterfaceData.concreteTypeNames);
+                        }
                         configurationData.isInterfaceObject = entityInterfaceData.isInterfaceObject;
                         configurationData.entityInterfaceConcreteTypeNames = entityInterfaceData.concreteTypeNames;
                     }
@@ -2014,17 +2514,16 @@ class NormalizationFactory {
                     if (events) {
                         configurationData.events = events;
                     }
-                    this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
-                    (0, utils_2.addFieldNamesToConfigurationData)(parentDefinitionData.fieldDataByFieldName, configurationData);
+                    this.addFieldNamesToConfigurationData(parentDefinitionData.fieldDataByFieldName, configurationData);
                     this.validateInterfaceImplementations(parentDefinitionData);
                     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));
+                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_5.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
                     }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    if (parentDefinitionData.extensionType === type_definition_data_1.ExtensionType.REAL) {
+                    if (parentDefinitionData.extensionType === types_1.ExtensionType.REAL) {
                         this.errors.push((0, errors_1.noBaseScalarDefinitionError)(parentTypeName));
                         break;
                     }
@@ -2039,10 +2538,14 @@ class NormalizationFactory {
                     throw (0, errors_1.unexpectedKindFatalError)(parentTypeName);
             }
         }
+        // this is where @provides and @requires configurations are added to the ConfigurationData
+        this.addValidConditionalFieldSetConfigurations();
+        // this is where @key configurations are added to the ConfigurationData
+        this.addValidKeyFieldSetConfigurations();
         // 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.schemaData.operationTypes.get(operationType);
-            const defaultTypeName = (0, utils_3.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType, string_constants_1.OPERATION_TO_DEFAULT);
+            const defaultTypeName = (0, utils_5.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType, string_constants_2.OPERATION_TO_DEFAULT);
             // If an operation type name was not declared, use the default
             const operationTypeName = operationTypeNode ? (0, ast_1.getTypeNodeNamedTypeName)(operationTypeNode.type) : defaultTypeName;
             // If a custom type is used, the default type should not be defined
@@ -2064,7 +2567,7 @@ class NormalizationFactory {
             if (!objectData) {
                 continue;
             }
-            const rootNode = this.configurationDataByParentTypeName.get(defaultTypeName);
+            const rootNode = this.configurationDataByTypeName.get(defaultTypeName);
             if (rootNode) {
                 rootNode.isRootNode = true;
                 rootNode.typeName = defaultTypeName;
@@ -2098,17 +2601,6 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }
-        this.validateAndAddKeysToConfiguration();
-        for (const [parentTypeName, fieldSetData] of this.fieldSetDataByTypeName) {
-            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName);
-            if (!parentData ||
-                (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
-                this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
-                continue;
-            }
-            // this is where keys, provides, and requires are added to the ConfigurationData
-            (0, utils_2.validateAndAddConditionalFieldSetsToConfiguration)(this, parentData, fieldSetData);
-        }
         const persistedDirectiveDefinitionDataByDirectiveName = new Map();
         for (const directiveDefinitionNode of this.directiveDefinitionByDirectiveName.values()) {
             // TODO @composeDirective directives would also be handled here
@@ -2131,34 +2623,33 @@ class NormalizationFactory {
             }
         }
         if (this.errors.length > 0) {
-            return { errors: this.errors, warnings: this.warnings };
+            return { success: false, errors: this.errors, warnings: this.warnings };
         }
         const newAST = {
             kind: graphql_1.Kind.DOCUMENT,
             definitions,
         };
         return {
-            normalizationResult: {
-                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.conditionalFieldDataByCoordinates,
-                configurationDataByTypeName: this.configurationDataByParentTypeName,
-                entityDataByTypeName: this.entityDataByTypeName,
-                entityInterfaces: this.entityInterfaceDataByTypeName,
-                isEventDrivenGraph: this.isSubgraphEventDrivenGraph,
-                isVersionTwo: this.isSubgraphVersionTwo,
-                keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
-                operationTypes: this.operationTypeNodeByTypeName,
-                originalTypeNameByRenamedTypeName: this.originalTypeNameByRenamedTypeName,
-                overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
-                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
-                persistedDirectiveDefinitionDataByDirectiveName,
-                subgraphAST: newAST,
-                subgraphString: (0, graphql_1.print)(newAST),
-                schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true, assumeValidSDL: true }),
-            },
+            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: this.configurationDataByTypeName,
+            entityDataByTypeName: this.entityDataByTypeName,
+            entityInterfaces: this.entityInterfaceDataByTypeName,
+            isEventDrivenGraph: this.isSubgraphEventDrivenGraph,
+            isVersionTwo: this.isSubgraphVersionTwo,
+            keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
+            operationTypes: this.operationTypeNodeByTypeName,
+            originalTypeNameByRenamedTypeName: this.originalTypeNameByRenamedTypeName,
+            overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
+            parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+            persistedDirectiveDefinitionDataByDirectiveName,
+            subgraphAST: newAST,
+            subgraphString: (0, graphql_1.print)(newAST),
+            schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true, assumeValidSDL: true }),
+            success: true,
             warnings: this.warnings,
         };
     }
@@ -2192,12 +2683,12 @@ function batchNormalize(subgraphs) {
         if (!subgraph.name) {
             invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
         }
-        const { errors, normalizationResult, warnings: normalizationWarnings, } = normalizeSubgraph(subgraph.definitions, subgraph.name, internalGraph);
-        if (normalizationWarnings.length > 0) {
-            warnings.push(...normalizationWarnings);
+        const normalizationResult = normalizeSubgraph(subgraph.definitions, subgraph.name, internalGraph);
+        if (normalizationResult.warnings.length > 0) {
+            warnings.push(...normalizationResult.warnings);
         }
-        if (errors) {
-            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, errors));
+        if (!normalizationResult.success) {
+            validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, normalizationResult.errors));
             continue;
         }
         if (!normalizationResult) {
@@ -2214,10 +2705,19 @@ function batchNormalize(subgraphs) {
                 concreteTypeNamesByAbstractTypeName.set(abstractTypeName, new Set(incomingConcreteTypeNames));
                 continue;
             }
-            (0, utils_3.addIterableValuesToSet)(incomingConcreteTypeNames, existingConcreteTypeNames);
+            (0, utils_5.addIterableValuesToSet)(incomingConcreteTypeNames, existingConcreteTypeNames);
         }
-        for (const entityData of normalizationResult.entityDataByTypeName.values()) {
-            (0, utils_3.upsertEntityData)(entityDataByTypeName, entityData);
+        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, {
@@ -2249,9 +2749,9 @@ function batchNormalize(subgraphs) {
                     warnings.push((0, warnings_1.invalidOverrideTargetSubgraphNameWarning)(targetSubgraphName, originalParentTypeName, [...fieldNames], subgraph.name));
                 }
                 else {
-                    const overridesData = (0, utils_3.getValueOrDefault)(allOverridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-                    const existingFieldNames = (0, utils_3.getValueOrDefault)(overridesData, parentTypeName, () => new Set(fieldNames));
-                    (0, utils_3.addIterableValuesToSet)(fieldNames, existingFieldNames);
+                    const overridesData = (0, utils_5.getValueOrDefault)(allOverridesByTargetSubgraphName, targetSubgraphName, () => new Map());
+                    const existingFieldNames = (0, utils_5.getValueOrDefault)(overridesData, parentTypeName, () => new Set(fieldNames));
+                    (0, utils_5.addIterableValuesToSet)(fieldNames, existingFieldNames);
                 }
                 for (const fieldName of fieldNames) {
                     const fieldPath = `${originalParentTypeName}.${fieldName}`;
@@ -2276,7 +2776,7 @@ function batchNormalize(subgraphs) {
     if (duplicateOverriddenFieldPaths.size > 0) {
         const duplicateOverriddenFieldErrorMessages = [];
         for (const fieldPath of duplicateOverriddenFieldPaths) {
-            const sourceSubgraphNames = (0, utils_3.getOrThrowError)(overrideSourceSubgraphNamesByFieldPath, fieldPath, 'overrideSourceSubgraphNamesByFieldPath');
+            const sourceSubgraphNames = (0, utils_5.getOrThrowError)(overrideSourceSubgraphNamesByFieldPath, fieldPath, 'overrideSourceSubgraphNamesByFieldPath');
             duplicateOverriddenFieldErrorMessages.push((0, errors_1.duplicateOverriddenFieldErrorMessage)(fieldPath, sourceSubgraphNames));
         }
         allErrors.push((0, errors_1.duplicateOverriddenFieldsError)(duplicateOverriddenFieldErrorMessages));
@@ -2284,17 +2784,13 @@ function batchNormalize(subgraphs) {
     allErrors.push(...validationErrors);
     if (allErrors.length > 0) {
         return {
-            authorizationDataByParentTypeName,
-            concreteTypeNamesByAbstractTypeName,
-            entityDataByTypeName,
             errors: allErrors,
-            internalSubgraphBySubgraphName,
-            internalGraph,
+            success: false,
             warnings,
         };
     }
     for (const [targetSubgraphName, overridesData] of allOverridesByTargetSubgraphName) {
-        const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphBySubgraphName, targetSubgraphName, 'internalSubgraphBySubgraphName');
+        const internalSubgraph = (0, utils_5.getOrThrowError)(internalSubgraphBySubgraphName, targetSubgraphName, 'internalSubgraphBySubgraphName');
         internalSubgraph.overriddenFieldNamesByParentTypeName = overridesData;
         for (const [parentTypeName, fieldNames] of overridesData) {
             const configurationData = internalSubgraph.configurationDataByTypeName.get(parentTypeName);
@@ -2313,6 +2809,7 @@ function batchNormalize(subgraphs) {
         entityDataByTypeName,
         internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
         internalGraph,
+        success: true,
         warnings,
     };
 }