@wundergraph/composition 0.37.0 → 0.37.1

package/dist/v1/normalization/utils.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newKeyFieldSetData = newKeyFieldSetData;
 exports.newFieldSetData = newFieldSetData;
-exports.addFieldNamesToConfigurationData = addFieldNamesToConfigurationData;
 exports.extractFieldSetValue = extractFieldSetValue;
 exports.getNormalizedFieldSet = getNormalizedFieldSet;
+exports.getInitialFieldCoordsPath = getInitialFieldCoordsPath;
 exports.validateKeyFieldSets = validateKeyFieldSets;
-exports.validateAndAddConditionalFieldSetsToConfiguration = validateAndAddConditionalFieldSetsToConfiguration;
+exports.getConditionalFieldSetDirectiveName = getConditionalFieldSetDirectiveName;
 exports.isNodeQuery = isNodeQuery;
 exports.validateArgumentTemplateReferences = validateArgumentTemplateReferences;
 exports.initializeDirectiveDefinitionDatas = initializeDirectiveDefinitionDatas;
@@ -14,43 +13,16 @@ const graphql_1 = require("graphql");
 const utils_1 = require("../../ast/utils");
 const errors_1 = require("../../errors/errors");
 const constants_1 = require("../utils/constants");
-const router_configuration_1 = require("../../router-configuration/router-configuration");
 const ast_1 = require("../../schema-building/ast");
-const utils_2 = require("../../schema-building/utils");
-const warnings_1 = require("../warnings/warnings");
 const directive_definition_data_1 = require("./directive-definition-data");
 const string_constants_1 = require("../../utils/string-constants");
-const utils_3 = require("../../utils/utils");
-function newKeyFieldSetData() {
-    return {
-        isUnresolvableByKeyFieldSet: new Map(),
-    };
-}
+const utils_2 = require("../../utils/utils");
 function newFieldSetData() {
     return {
         provides: new Map(),
         requires: new Map(),
     };
 }
-function addFieldNamesToConfigurationData(fieldDataByFieldName, configurationData) {
-    const externalFieldNames = new Set();
-    for (const [fieldName, fieldContainer] of fieldDataByFieldName) {
-        if (fieldContainer.directivesByDirectiveName.has(string_constants_1.EXTERNAL)) {
-            if (configurationData.externalFieldNames) {
-                configurationData.externalFieldNames.add(fieldName);
-            }
-            else {
-                externalFieldNames.add(fieldName);
-            }
-        }
-        else {
-            configurationData.fieldNames.add(fieldName);
-        }
-    }
-    if (externalFieldNames.size > 0) {
-        configurationData.externalFieldNames = externalFieldNames;
-    }
-}
 function extractFieldSetValue(name, map, directives) {
     // ALl directive validation errors are accounted for later
     // Requires and provides should not be repeatable, so the length should be no more than 1
@@ -78,249 +50,28 @@ function getNormalizedFieldSet(documentNode) {
     */
     return (0, graphql_1.print)((0, utils_1.lexicographicallySortDocumentNode)(documentNode)).replaceAll(/\s+/g, ' ').slice(2, -2);
 }
-function getInitialFieldCoordinatesPath(fieldSetDirective, directiveParentTypeName, directiveFieldName) {
-    switch (fieldSetDirective) {
-        case utils_2.FieldSetDirective.PROVIDES:
-            return [`${directiveParentTypeName}.${directiveFieldName}`];
-        default:
-            return [];
+function getInitialFieldCoordsPath(isProvides, directiveCoords) {
+    if (isProvides) {
+        return [directiveCoords];
     }
+    return [];
 }
-function validateNonRepeatableFieldSet(nf, selectionSetParentData, fieldSet, directiveFieldName, fieldSetDirective, 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 { errorMessage: (0, errors_1.unparsableFieldSetErrorMessage)(fieldSet, error) };
-    }
-    const parentDatas = [selectionSetParentData];
-    const definedFields = [];
-    const fieldCoordinatesPath = getInitialFieldCoordinatesPath(fieldSetDirective, directiveParentTypeName, directiveFieldName);
-    const fieldPath = [directiveFieldName];
-    const externalAncestors = new Set();
-    let errorMessage;
-    let currentDepth = -1;
-    let shouldDefineSelectionSet = true;
-    let lastFieldName = directiveFieldName;
-    (0, graphql_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) {
-                    errorMessage = (0, errors_1.invalidSelectionOnUnionErrorMessage)(fieldSet, fieldCoordinatesPath, parentTypeName);
-                    return graphql_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) {
-                    errorMessage = (0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, fieldCoordinatesPath, parentTypeName, (0, utils_3.kindToTypeString)(parentData.kind));
-                    return graphql_1.BREAK;
-                }
-                fieldCoordinatesPath.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) {
-                    errorMessage = (0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentTypeName, fieldName);
-                    return graphql_1.BREAK;
-                }
-                if (definedFields[currentDepth].has(fieldName)) {
-                    errorMessage = (0, errors_1.duplicateFieldInFieldSetErrorMessage)(fieldSet, currentFieldCoords);
-                    return graphql_1.BREAK;
-                }
-                definedFields[currentDepth].add(fieldName);
-                const isExternal = fieldData.isExternalBySubgraphName.get(nf.subgraphName);
-                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 && !isExternal) {
-                        if (nf.isSubgraphVersionTwo) {
-                            nf.errors.push((0, errors_1.nonExternalConditionalFieldError)(`${directiveParentTypeName}.${directiveFieldName}`, nf.subgraphName, currentFieldCoords, fieldSet, fieldSetDirective));
-                        }
-                        else {
-                            /* 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)(`${directiveParentTypeName}.${directiveFieldName}`, nf.subgraphName, currentFieldCoords, fieldSet, fieldSetDirective));
-                        }
-                        return;
-                    }
-                    const conditionalFieldData = (0, utils_3.getValueOrDefault)(nf.conditionalFieldDataByCoordinates, currentFieldCoords, utils_2.newConditionalFieldData);
-                    const fieldSetCondition = (0, router_configuration_1.newFieldSetConditionData)({
-                        fieldCoordinatesPath: [...fieldCoordinatesPath],
-                        fieldPath: [...fieldPath],
-                    });
-                    fieldSetDirective === utils_2.FieldSetDirective.PROVIDES
-                        ? conditionalFieldData.providedBy.push(fieldSetCondition)
-                        : conditionalFieldData.requiredBy.push(fieldSetCondition);
-                    return;
-                }
-                if (!namedTypeData) {
-                    // Should not be possible to receive this error
-                    errorMessage = (0, errors_1.unknownTypeInFieldSetErrorMessage)(fieldSet, currentFieldCoords, namedTypeName);
-                    return graphql_1.BREAK;
-                }
-                if (isExternal) {
-                    const data = (0, utils_3.getValueOrDefault)(nf.conditionalFieldDataByCoordinates, currentFieldCoords, utils_2.newConditionalFieldData);
-                    switch (fieldSetDirective) {
-                        case utils_2.FieldSetDirective.PROVIDES:
-                            data.providedBy.push((0, router_configuration_1.newFieldSetConditionData)({
-                                fieldCoordinatesPath: [...fieldCoordinatesPath],
-                                fieldPath: [...fieldPath],
-                            }));
-                            break;
-                        default:
-                            break;
-                    }
-                    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(fieldCoordinatesPath.pop() || '');
-                fieldPath.pop();
-            },
-        },
-        InlineFragment: {
-            enter(node) {
-                const parentData = parentDatas[currentDepth];
-                const parentTypeName = parentData.name;
-                const fieldCoordinates = fieldCoordinatesPath.length < 1
-                    ? selectionSetParentData.name
-                    : fieldCoordinatesPath[fieldCoordinatesPath.length - 1];
-                if (!node.typeCondition) {
-                    errorMessage = (0, errors_1.inlineFragmentWithoutTypeConditionErrorMessage)(fieldSet, fieldCoordinates);
-                    return graphql_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)) {
-                    errorMessage = (0, errors_1.invalidInlineFragmentTypeErrorMessage)(fieldSet, fieldCoordinatesPath, typeConditionName, parentTypeName);
-                    return graphql_1.BREAK;
-                }
-                const fragmentNamedTypeData = nf.parentDefinitionDataByTypeName.get(typeConditionName);
-                if (!fragmentNamedTypeData) {
-                    errorMessage = (0, errors_1.unknownInlineFragmentTypeConditionErrorMessage)(fieldSet, fieldCoordinatesPath, parentTypeName, typeConditionName);
-                    return graphql_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: {
-                        errorMessage = (0, errors_1.invalidInlineFragmentTypeConditionTypeErrorMessage)(fieldSet, fieldCoordinatesPath, parentTypeName, typeConditionName, (0, utils_3.kindToTypeString)(fragmentNamedTypeData.kind));
-                        return graphql_1.BREAK;
-                    }
-                }
-                errorMessage = (0, errors_1.invalidInlineFragmentTypeConditionErrorMessage)(fieldSet, fieldCoordinatesPath, typeConditionName, (0, utils_3.kindToTypeString)(parentData.kind), parentTypeName);
-                return graphql_1.BREAK;
-            },
-        },
-        SelectionSet: {
-            enter() {
-                if (!shouldDefineSelectionSet) {
-                    const parentData = parentDatas[currentDepth];
-                    if (parentData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
-                        // Should never happen
-                        errorMessage = (0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName);
-                        return graphql_1.BREAK;
-                    }
-                    const fieldData = parentData.fieldDataByFieldName.get(lastFieldName);
-                    if (!fieldData) {
-                        errorMessage = (0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentData.name, lastFieldName);
-                        return graphql_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;
-                    errorMessage = (0, errors_1.invalidSelectionSetDefinitionErrorMessage)(fieldSet, fieldCoordinatesPath, fieldNamedTypeName, (0, utils_3.kindToTypeString)(childKind));
-                    return graphql_1.BREAK;
-                }
-                currentDepth += 1;
-                shouldDefineSelectionSet = false;
-                if (currentDepth < 0 || currentDepth >= parentDatas.length) {
-                    errorMessage = (0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName);
-                    return graphql_1.BREAK;
-                }
-                definedFields.push(new Set());
-            },
-            leave() {
-                if (shouldDefineSelectionSet) {
-                    const parentData = parentDatas[currentDepth + 1];
-                    errorMessage = (0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, fieldCoordinatesPath, parentData.name, (0, utils_3.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 (errorMessage) {
-        return { errorMessage };
-    }
-    return { configuration: { fieldName: directiveFieldName, selectionSet: getNormalizedFieldSet(documentNode) } };
-}
-function validateKeyFieldSets(nf, entityParentData, nonResolvableByKeyFieldSet, fieldNames) {
-    const isEntityInterface = nf.entityInterfaceDataByTypeName.has(entityParentData.name);
+function validateKeyFieldSets(nf, entityParentData, keyFieldSetDataByFieldSet, fieldNames) {
+    const entityInterfaceData = nf.entityInterfaceDataByTypeName.get(entityParentData.name);
     const entityTypeName = entityParentData.name;
-    const errorMessages = [];
     const configurations = [];
-    const keyFieldNames = new Set();
     const allKeyFieldSetPaths = [];
     // If the key is on an entity interface/interface object, an entity data node should not be propagated
-    const entityDataNode = isEntityInterface ? undefined : nf.internalGraph.addEntityDataNode(entityParentData.name);
+    const entityDataNode = entityInterfaceData ? undefined : nf.internalGraph.addEntityDataNode(entityParentData.name);
     const graphNode = nf.internalGraph.addOrUpdateNode(entityParentData.name);
-    for (const [fieldSet, disableEntityResolver] of nonResolvableByKeyFieldSet) {
-        // 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) {
-            errorMessages.push((0, errors_1.unparsableFieldSetErrorMessage)(fieldSet, error));
-            continue;
+    let keyNumber = 0;
+    for (const [fieldSet, { documentNode, isUnresolvable, rawFieldSet }] of keyFieldSetDataByFieldSet) {
+        if (entityInterfaceData) {
+            entityInterfaceData.resolvable ||= !isUnresolvable;
         }
-        const parentWithFieldsDatas = [entityParentData];
+        keyNumber += 1;
+        const errorMessages = [];
+        const parentDatas = [entityParentData];
         const definedFields = [];
         const currentPath = [];
         const keyFieldSetPaths = new Set();
@@ -332,59 +83,52 @@ function validateKeyFieldSets(nf, entityParentData, nonResolvableByKeyFieldSet,
                 enter(node) {
                     // Fields that define arguments are never allowed in a key FieldSet
                     // However, at this stage, it actually means the argument is undefined on the field
-                    errorMessages.push((0, errors_1.unexpectedArgumentErrorMessage)(fieldSet, `${parentWithFieldsDatas[currentDepth].name}.${lastFieldName}`, node.name.value));
+                    errorMessages.push((0, errors_1.unexpectedArgumentErrorMessage)(rawFieldSet, `${parentDatas[currentDepth].name}.${lastFieldName}`, node.name.value));
                     return graphql_1.BREAK;
                 },
             },
             Field: {
                 enter(node) {
-                    const grandparentData = parentWithFieldsDatas[currentDepth - 1];
-                    const parentData = parentWithFieldsDatas[currentDepth];
+                    const parentData = parentDatas[currentDepth];
                     const parentTypeName = parentData.name;
-                    const fieldName = node.name.value;
-                    const fieldCoords = `${parentTypeName}.${fieldName}`;
-                    nf.unvalidatedExternalFieldCoords.delete(fieldCoords);
-                    // If an object-like was just visited, a selection set should have been entered
+                    // If a composite type was just visited, a selection set should have been entered
                     if (shouldDefineSelectionSet) {
-                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, [`${grandparentData.name}.${lastFieldName}`], parentTypeName, (0, utils_3.kindToTypeString)(parentData.kind)));
+                        const lastFieldCoords = `${parentTypeName}.${lastFieldName}`;
+                        const lastFieldData = parentData.fieldDataByFieldName.get(lastFieldName);
+                        if (!lastFieldData) {
+                            errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(rawFieldSet, lastFieldCoords, lastFieldName));
+                            return graphql_1.BREAK;
+                        }
+                        const lastFieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(lastFieldData.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(lastFieldNamedTypeName);
+                        const namedTypeKind = namedTypeData ? namedTypeData.kind : graphql_1.Kind.SCALAR_TYPE_DEFINITION;
+                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(rawFieldSet, [lastFieldCoords], lastFieldNamedTypeName, (0, utils_2.kindToTypeString)(namedTypeKind)));
                         return graphql_1.BREAK;
                     }
+                    const fieldName = node.name.value;
+                    const fieldCoords = `${parentTypeName}.${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));
+                        errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(rawFieldSet, parentTypeName, fieldName));
                         return graphql_1.BREAK;
                     }
                     // TODO navigate already provided keys
                     if (fieldData.argumentDataByArgumentName.size) {
-                        errorMessages.push((0, errors_1.argumentsInKeyFieldSetErrorMessage)(fieldSet, fieldCoords));
+                        errorMessages.push((0, errors_1.argumentsInKeyFieldSetErrorMessage)(rawFieldSet, fieldCoords));
                         return graphql_1.BREAK;
                     }
                     if (definedFields[currentDepth].has(fieldName)) {
-                        errorMessages.push((0, errors_1.duplicateFieldInFieldSetErrorMessage)(fieldSet, fieldCoords));
+                        errorMessages.push((0, errors_1.duplicateFieldInFieldSetErrorMessage)(rawFieldSet, fieldCoords));
                         return graphql_1.BREAK;
                     }
                     currentPath.push(fieldName);
                     // Fields that form part of an entity key are intrinsically shareable
                     fieldData.isShareableBySubgraphName.set(nf.subgraphName, true);
                     definedFields[currentDepth].add(fieldName);
-                    /* Depth 0 is the original parent type
-                     * If a field is external, but it's part of a key FieldSet, it should be included in its respective
-                     * root or child node */
-                    if (currentDepth === 0) {
-                        keyFieldNames.add(fieldName);
-                        fieldNames.add(fieldName);
-                    }
-                    else {
-                        const nestedConfigurationData = nf.configurationDataByParentTypeName.get(parentTypeName);
-                        if (!nestedConfigurationData) {
-                            errorMessages.push((0, errors_1.invalidConfigurationDataErrorMessage)(parentTypeName, fieldName, fieldSet));
-                            return graphql_1.BREAK;
-                        }
-                        nestedConfigurationData.fieldNames.add(fieldName);
-                    }
-                    (0, utils_3.getValueOrDefault)(nf.keyFieldNamesByParentTypeName, parentTypeName, () => new Set()).add(fieldName);
+                    (0, utils_2.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)) {
@@ -396,17 +140,17 @@ function validateKeyFieldSets(nf, entityParentData, nonResolvableByKeyFieldSet,
                     const namedTypeData = nf.parentDefinitionDataByTypeName.get(namedTypeName);
                     if (!namedTypeData) {
                         // Should not be possible to receive this error
-                        errorMessages.push((0, errors_1.unknownTypeInFieldSetErrorMessage)(fieldSet, fieldCoords, namedTypeName));
+                        errorMessages.push((0, errors_1.unknownTypeInFieldSetErrorMessage)(rawFieldSet, fieldCoords, namedTypeName));
                         return graphql_1.BREAK;
                     }
                     if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                         shouldDefineSelectionSet = true;
-                        parentWithFieldsDatas.push(namedTypeData);
+                        parentDatas.push(namedTypeData);
                         return;
                     }
                     // interfaces and unions are invalid in a key directive
                     if ((0, utils_1.isKindAbstract)(namedTypeData.kind)) {
-                        errorMessages.push((0, errors_1.abstractTypeInKeyFieldSetErrorMessage)(fieldSet, fieldCoords, namedTypeName, (0, utils_3.kindToTypeString)(namedTypeData.kind)));
+                        errorMessages.push((0, errors_1.abstractTypeInKeyFieldSetErrorMessage)(rawFieldSet, fieldCoords, namedTypeName, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
                         return graphql_1.BREAK;
                     }
                     keyFieldSetPaths.add(currentPath.join(string_constants_1.PERIOD));
@@ -422,140 +166,73 @@ function validateKeyFieldSets(nf, entityParentData, nonResolvableByKeyFieldSet,
             SelectionSet: {
                 enter() {
                     if (!shouldDefineSelectionSet) {
-                        const parentData = parentWithFieldsDatas[currentDepth];
+                        const parentData = parentDatas[currentDepth];
                         const parentTypeName = parentData.name;
                         const fieldCoordinates = `${parentTypeName}.${lastFieldName}`;
                         // If the last field is not an object-like
                         const fieldData = parentData.fieldDataByFieldName.get(lastFieldName);
                         if (!fieldData) {
-                            errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, fieldCoordinates, lastFieldName));
+                            errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(rawFieldSet, fieldCoordinates, lastFieldName));
                             return graphql_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 namedTypeKind = namedTypeData ? namedTypeData.kind : graphql_1.Kind.SCALAR_TYPE_DEFINITION;
-                        errorMessages.push((0, errors_1.invalidSelectionSetDefinitionErrorMessage)(fieldSet, [fieldCoordinates], fieldNamedTypeName, (0, utils_3.kindToTypeString)(namedTypeKind)));
+                        errorMessages.push((0, errors_1.invalidSelectionSetDefinitionErrorMessage)(rawFieldSet, [fieldCoordinates], fieldNamedTypeName, (0, utils_2.kindToTypeString)(namedTypeKind)));
                         return graphql_1.BREAK;
                     }
                     currentDepth += 1;
                     shouldDefineSelectionSet = false;
-                    if (currentDepth < 0 || currentDepth >= parentWithFieldsDatas.length) {
-                        errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName));
+                    if (currentDepth < 0 || currentDepth >= parentDatas.length) {
+                        errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(rawFieldSet, lastFieldName));
                         return graphql_1.BREAK;
                     }
                     definedFields.push(new Set());
                 },
                 leave() {
                     if (shouldDefineSelectionSet) {
-                        const grandparentData = parentWithFieldsDatas[currentDepth];
+                        const grandparentData = parentDatas[currentDepth];
                         const grandparentTypeName = grandparentData.name;
-                        const parentData = parentWithFieldsDatas[currentDepth + 1];
+                        const parentData = parentDatas[currentDepth + 1];
                         const fieldCoordinates = `${grandparentTypeName}.${lastFieldName}`;
-                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(fieldSet, [fieldCoordinates], parentData.name, (0, utils_3.kindToTypeString)(parentData.kind)));
+                        errorMessages.push((0, errors_1.invalidSelectionSetErrorMessage)(rawFieldSet, [fieldCoordinates], parentData.name, (0, utils_2.kindToTypeString)(parentData.kind)));
                         shouldDefineSelectionSet = false;
                     }
                     // Empty selection sets would be a parse error, so it is unnecessary to handle them
                     currentDepth -= 1;
-                    parentWithFieldsDatas.pop();
+                    parentDatas.pop();
                     definedFields.pop();
                 },
             },
         });
         if (errorMessages.length > 0) {
+            nf.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.KEY, entityTypeName, (0, utils_2.numberToOrdinal)(keyNumber), errorMessages));
             continue;
         }
-        const normalizedFieldSet = getNormalizedFieldSet(documentNode);
         configurations.push({
             fieldName: '',
-            selectionSet: normalizedFieldSet,
-            ...(disableEntityResolver ? { disableEntityResolver: true } : {}),
+            selectionSet: fieldSet,
+            ...(isUnresolvable ? { disableEntityResolver: true } : {}),
         });
-        graphNode.satisfiedFieldSets.add(normalizedFieldSet);
-        if (disableEntityResolver) {
+        graphNode.satisfiedFieldSets.add(fieldSet);
+        if (isUnresolvable) {
             continue;
         }
-        entityDataNode?.addTargetSubgraphByFieldSet(normalizedFieldSet, nf.subgraphName);
+        entityDataNode?.addTargetSubgraphByFieldSet(fieldSet, nf.subgraphName);
         allKeyFieldSetPaths.push(keyFieldSetPaths);
     }
-    if (errorMessages.length) {
-        nf.errors.push((0, errors_1.invalidKeyDirectivesError)(entityTypeName, errorMessages));
-        return;
-    }
     // todo
     // nf.internalGraph.addEntityNode(entityTypeName, allKeyFieldSetPaths);
-    if (configurations.length) {
-        return configurations;
-    }
-}
-function getFieldSetParent(factory, fieldSetDirective, parentData, fieldName, parentTypeName) {
-    if (fieldSetDirective !== utils_2.FieldSetDirective.PROVIDES) {
-        return { fieldSetParentData: parentData };
-    }
-    const fieldData = (0, utils_3.getOrThrowError)(parentData.fieldDataByFieldName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
-    const fieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
-    const namedTypeData = factory.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 };
-}
-function validateProvidesOrRequires(nf, parentData, fieldSetByFieldName, fieldSetDirective) {
-    const errorMessages = [];
-    const configurations = [];
-    const parentTypeName = (0, utils_2.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 } = getFieldSetParent(nf, fieldSetDirective, parentData, fieldName, parentTypeName);
-        const fieldCoords = `${parentTypeName}.${fieldName}`;
-        if (errorString) {
-            errorMessages.push(errorString);
-            continue;
-        }
-        if (!fieldSetParentData) {
-            continue;
-        }
-        const { errorMessage, configuration } = validateNonRepeatableFieldSet(nf, fieldSetParentData, fieldSet, fieldName, fieldSetDirective, parentTypeName);
-        if (errorMessage) {
-            errorMessages.push(` On "${fieldCoords}" —` + errorMessage);
-            continue;
-        }
-        if (configuration) {
-            configurations.push(configuration);
-            continue;
-        }
-        // Should never happen
-        throw (0, errors_1.invalidConfigurationResultFatalError)(fieldCoords);
-    }
-    if (errorMessages.length > 0) {
-        nf.errors.push((0, errors_1.invalidProvidesOrRequiresDirectivesError)(fieldSetDirective, errorMessages));
-        return;
-    }
     if (configurations.length > 0) {
         return configurations;
     }
 }
-function validateAndAddConditionalFieldSetsToConfiguration(nf, parentData, fieldSetData) {
-    const configurationData = (0, utils_3.getOrThrowError)(nf.configurationDataByParentTypeName, (0, utils_2.getParentTypeName)(parentData), 'configurationDataByParentTypeName');
-    const provides = validateProvidesOrRequires(nf, parentData, fieldSetData.provides, utils_2.FieldSetDirective.PROVIDES);
-    if (provides) {
-        configurationData.provides = provides;
-    }
-    const requires = validateProvidesOrRequires(nf, parentData, fieldSetData.requires, utils_2.FieldSetDirective.REQUIRES);
-    if (requires) {
-        configurationData.requires = requires;
+function getConditionalFieldSetDirectiveName(isProvides) {
+    if (isProvides) {
+        return string_constants_1.PROVIDES;
     }
+    return string_constants_1.REQUIRES;
 }
 function isNodeQuery(typeName, operationTypeNode) {
     return typeName === string_constants_1.QUERY || operationTypeNode === graphql_1.OperationTypeNode.QUERY;