@wundergraph/composition 0.37.0 → 0.37.1

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

@@ -24,6 +24,8 @@ 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) {
@@ -41,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();
@@ -52,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 = [];
@@ -62,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();
@@ -81,6 +83,7 @@ class NormalizationFactory {
     referencedTypeNames = new Set();
     renamedParentTypeName = '';
     subgraphName;
+    unvalidatedExternalFieldCoords = new Set();
     usesEdfsNatsStreamConfiguration = false;
     warnings = [];
     constructor(internalGraph, subgraphName) {
@@ -488,13 +491,13 @@ class NormalizationFactory {
         /*
          * @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_2.EXTENDS)) {
+        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
+        // If a V1 non-root Object defines @extends, it is considered an extension across subgraphs.
         return types_1.ExtensionType.EXTENDS;
     }
     setParentDataExtensionType(parentData, incomingExtensionType) {
@@ -725,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],
+            externalFieldDataBySubgraphName: new Map([
+                [this.subgraphName, (0, utils_4.newExternalFieldData)(isExternal)],
             ]),
             isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
-            isShareableBySubgraphName: new Map([
-                [this.subgraphName, isNodeExternalOrShareableResult.isShareable],
-            ]),
+            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),
         };
@@ -1031,23 +1032,24 @@ 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_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_2.RESOLVABLE) {
@@ -1057,18 +1059,339 @@ class NormalizationFactory {
                     continue;
                 }
                 if (arg.name.value !== string_constants_2.FIELDS) {
-                    keyFieldSet = undefined;
+                    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 (keyFieldSet !== undefined) {
-                isUnresolvableByRawKeyFieldSet.set(keyFieldSet, isUnresolvable);
+            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 (!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) {
@@ -1575,11 +1898,11 @@ 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;
             }
@@ -1590,7 +1913,7 @@ class NormalizationFactory {
         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;
@@ -1765,22 +2088,20 @@ class NormalizationFactory {
             this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(unionTypeName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(memberTypeName), memberTypeName, true);
         }
     }
-    validateAndAddKeyToConfiguration(parentData, keyFieldSetData) {
-        const configurationData = (0, utils_5.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) {
@@ -1862,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,
@@ -1953,6 +2447,8 @@ class NormalizationFactory {
                 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:
@@ -1976,6 +2472,10 @@ 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_2.SERVICE_FIELD);
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_2.ENTITIES_FIELD);
@@ -1985,7 +2485,7 @@ class NormalizationFactory {
                     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
@@ -1998,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_5.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;
                     }
@@ -2017,8 +2514,7 @@ 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
@@ -2042,6 +2538,10 @@ 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);
@@ -2067,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;
@@ -2101,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
@@ -2145,8 +2634,8 @@ class NormalizationFactory {
             // 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,
+            conditionalFieldDataByCoordinates: this.conditionalFieldDataByCoords,
+            configurationDataByTypeName: this.configurationDataByTypeName,
             entityDataByTypeName: this.entityDataByTypeName,
             entityInterfaces: this.entityInterfaceDataByTypeName,
             isEventDrivenGraph: this.isSubgraphEventDrivenGraph,
@@ -2218,8 +2707,17 @@ function batchNormalize(subgraphs) {
             }
             (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, {