@wundergraph/composition 0.37.2 → 0.38.0

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

@@ -28,12 +28,13 @@ class FederationFactory {
     concreteTypeNamesByAbstractTypeName;
     clientDefinitions = [constants_1.DEPRECATED_DEFINITION];
     currentSubgraphName = '';
-    subgraphNamesByNamedTypeNameByFieldCoordinates = new Map();
+    subgraphNamesByNamedTypeNameByFieldCoords = new Map();
     entityDataByTypeName;
     entityInterfaceFederationDataByTypeName;
     errors = [];
-    fieldConfigurationByFieldPath = new Map();
-    inaccessiblePaths = new Set();
+    fieldConfigurationByFieldCoords = new Map();
+    inaccessibleCoords = new Set();
+    inaccessibleRequiredInputValueErrorByCoords = new Map();
     isMaxDepth = false;
     internalGraph;
     internalSubgraphBySubgraphName;
@@ -43,7 +44,7 @@ class FederationFactory {
     namedOutputTypeNames = new Set();
     parentDefinitionDataByTypeName = new Map();
     parentTagDataByTypeName = new Map();
-    pathsByNamedTypeName = new Map();
+    coordsByNamedTypeName = new Map();
     persistedDirectiveDefinitionByDirectiveName = new Map([
         [string_constants_2.AUTHENTICATED, constants_1.AUTHENTICATED_DEFINITION],
         [string_constants_2.DEPRECATED, constants_1.DEPRECATED_DEFINITION],
@@ -54,9 +55,8 @@ class FederationFactory {
     persistedDirectiveDefinitions = new Set([string_constants_2.AUTHENTICATED, string_constants_2.DEPRECATED, string_constants_2.INACCESSIBLE, string_constants_2.TAG, string_constants_2.REQUIRES_SCOPES]);
     potentialPersistedDirectiveDefinitionDataByDirectiveName = new Map();
     routerDefinitions = [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
-    shareableErrorTypeNames = new Map();
     subscriptionFilterDataByFieldPath = new Map();
-    tagNamesByPath = new Map();
+    tagNamesByCoords = new Map();
     warnings;
     constructor(params) {
         this.authorizationDataByParentTypeName = params.authorizationDataByParentTypeName;
@@ -225,7 +225,7 @@ class FederationFactory {
     addValidPrimaryKeyTargetsFromInterfaceObject(internalSubgraph, interfaceObjectTypeName, entityData, graphNode) {
         const parentDefinitionDataByTypeName = internalSubgraph.parentDefinitionDataByTypeName;
         const interfaceObjectData = parentDefinitionDataByTypeName.get(interfaceObjectTypeName);
-        if (!interfaceObjectData || interfaceObjectData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+        if (!interfaceObjectData || !(0, utils_5.isParentDataCompositeOutputType)(interfaceObjectData)) {
             throw (0, errors_1.incompatibleParentKindFatalError)(interfaceObjectTypeName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceObjectData?.kind || graphql_1.Kind.NULL);
         }
         const configurationData = (0, utils_6.getOrThrowError)(internalSubgraph.configurationDataByTypeName, entityData.typeName, 'internalSubgraph.configurationDataByTypeName');
@@ -267,7 +267,7 @@ class FederationFactory {
         return utils_5.MergeMethod.UNION;
     }
     generateTagData() {
-        for (const [path, tagNames] of this.tagNamesByPath) {
+        for (const [path, tagNames] of this.tagNamesByCoords) {
             const paths = path.split('.');
             if (paths.length < 1) {
                 continue;
@@ -302,100 +302,93 @@ class FederationFactory {
     }
     upsertEnumValueData(enumValueDataByValueName, incomingData, isParentInaccessible) {
         const existingData = enumValueDataByValueName.get(incomingData.name);
-        const baseData = existingData || incomingData;
-        const enumValuePath = `${incomingData.parentTypeName}.${incomingData.name}`;
-        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
-        if (isParentInaccessible || isFieldInaccessible) {
-            this.inaccessiblePaths.add(enumValuePath);
-        }
-        this.recordTagNamesByPath(baseData, enumValuePath);
+        const targetData = existingData || this.copyEnumValueData(incomingData);
+        (0, utils_5.extractPersistedDirectives)(targetData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isValueInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
+        if (isParentInaccessible || isValueInaccessible) {
+            this.inaccessibleCoords.add(targetData.federatedCoords);
+        }
+        this.recordTagNamesByCoords(targetData, targetData.federatedCoords);
         if (!existingData) {
-            incomingData.node = {
-                directives: [],
-                kind: incomingData.node.kind,
-                name: (0, utils_1.stringToNameNode)(incomingData.name),
-            };
-            enumValueDataByValueName.set(incomingData.name, incomingData);
+            enumValueDataByValueName.set(targetData.name, targetData);
             return;
         }
-        existingData.appearances += 1;
-        (0, utils_3.addMapEntries)(incomingData.configureDescriptionDataBySubgraphName, existingData.configureDescriptionDataBySubgraphName);
-        (0, utils_5.setLongestDescription)(existingData, incomingData);
-        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+        targetData.appearances += 1;
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.configureDescriptionDataBySubgraphName, targetData.configureDescriptionDataBySubgraphName);
+        (0, utils_5.setLongestDescription)(targetData, incomingData);
+        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, targetData.subgraphNames);
     }
     // To facilitate the splitting of tag paths, field arguments do not use the renamedPath property for tagNamesByPath
-    upsertInputValueData(inputValueDataByValueName, incomingData, path) {
+    upsertInputValueData(inputValueDataByValueName, incomingData, parentCoords, isParentInaccessible) {
         const existingData = inputValueDataByValueName.get(incomingData.name);
-        const baseData = existingData || incomingData;
-        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-        this.recordTagNamesByPath(baseData, path || baseData.renamedPath);
+        const targetData = existingData || this.copyInputValueData(incomingData);
+        (0, utils_5.extractPersistedDirectives)(targetData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        this.recordTagNamesByCoords(targetData, `${parentCoords}.${targetData.name}`);
+        this.namedInputValueTypeNames.add(targetData.namedTypeName);
+        (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, targetData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
         if (!existingData) {
-            incomingData.node = {
-                directives: [],
-                kind: incomingData.node.kind,
-                name: (0, utils_1.stringToNameNode)(incomingData.name),
-                type: incomingData.type,
-            };
-            inputValueDataByValueName.set(incomingData.name, incomingData);
+            inputValueDataByValueName.set(targetData.name, targetData);
             return;
         }
-        (0, utils_3.addMapEntries)(incomingData.configureDescriptionDataBySubgraphName, existingData.configureDescriptionDataBySubgraphName);
-        (0, utils_5.setLongestDescription)(existingData, incomingData);
-        (0, utils_6.addIterableValuesToSet)(incomingData.requiredSubgraphNames, existingData.requiredSubgraphNames);
-        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.configureDescriptionDataBySubgraphName, targetData.configureDescriptionDataBySubgraphName);
+        (0, utils_5.setLongestDescription)(targetData, incomingData);
+        (0, utils_6.addIterableValuesToSet)(incomingData.requiredSubgraphNames, targetData.requiredSubgraphNames);
+        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, targetData.subgraphNames);
+        this.handleInputValueInaccessibility(isParentInaccessible, targetData, parentCoords);
         // TODO refactor type merging
-        const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingData.type, incomingData.type, existingData.originalPath, this.errors);
+        const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(targetData.type, incomingData.type, targetData.originalCoords, this.errors);
         if (typeNode) {
-            existingData.type = typeNode;
+            targetData.type = typeNode;
         }
         else {
             if (!typeErrors || typeErrors.length < 2) {
-                throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+                throw (0, errors_1.fieldTypeMergeFatalError)(targetData.name);
             }
             existingData.isArgument
-                ? this.errors.push((0, errors_1.incompatibleArgumentTypesError)(existingData.name, existingData.renamedPath, typeErrors[0], typeErrors[1]))
-                : this.errors.push((0, errors_1.incompatibleChildTypesError)(existingData.renamedPath, typeErrors[0], typeErrors[1]));
+                ? this.errors.push((0, errors_1.incompatibleArgumentTypesError)(targetData.name, targetData.federatedCoords, typeErrors[0], typeErrors[1]))
+                : this.errors.push((0, errors_1.incompatibleChildTypesError)(targetData.federatedCoords, typeErrors[0], typeErrors[1]));
         }
-        (0, utils_5.compareAndValidateInputValueDefaultValues)(existingData, incomingData, this.errors);
+        (0, utils_5.compareAndValidateInputValueDefaultValues)(targetData, incomingData, this.errors);
     }
-    handleArgumentInaccessibility(isParentInaccessible, inputValueData, argumentPath, fieldPath) {
-        /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
-         ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
-         ** error. */
+    handleInputValueInaccessibility(isParentInaccessible, inputValueData, parentCoords) {
+        /* If an ancestor (Input Object for field; Composite type or field for argument) of the input value is
+         * @inaccessible, nullability is not considered.
+         * However, if only the input value (field or argument) itself is @inaccessible, an error is returned.
+         */
         if (isParentInaccessible) {
-            this.inaccessiblePaths.add(argumentPath);
+            this.inaccessibleRequiredInputValueErrorByCoords.delete(inputValueData.federatedCoords);
+            this.inaccessibleCoords.add(inputValueData.federatedCoords);
             return;
         }
         if (!(0, utils_5.isNodeDataInaccessible)(inputValueData)) {
             return;
         }
         if ((0, utils_5.isTypeRequired)(inputValueData.type)) {
-            this.errors.push((0, errors_1.inaccessibleRequiredArgumentError)(inputValueData.name, argumentPath, fieldPath));
-        }
-        else {
-            this.inaccessiblePaths.add(argumentPath);
+            this.inaccessibleRequiredInputValueErrorByCoords.set(inputValueData.federatedCoords, (0, errors_1.inaccessibleRequiredInputValueError)(inputValueData, parentCoords));
+            return;
         }
+        this.inaccessibleCoords.add(inputValueData.federatedCoords);
     }
-    handleSubscriptionFilterDirective(incomingData, fieldPath, baseData) {
+    handleSubscriptionFilterDirective(incomingData, targetData) {
         const subscriptionFilters = incomingData.directivesByDirectiveName.get(string_constants_2.SUBSCRIPTION_FILTER);
-        if (subscriptionFilters) {
-            // There should only be a single entry in the set
-            const subgraphName = (0, utils_3.getSingleSetEntry)(incomingData.subgraphNames);
-            if (subgraphName === undefined) {
-                this.errors.push((0, errors_1.unknownFieldSubgraphNameError)(fieldPath));
-                return;
-            }
-            // @openfed__subscriptionFilter is non-repeatable
-            this.subscriptionFilterDataByFieldPath.set(fieldPath, {
-                directive: subscriptionFilters[0],
-                fieldData: baseData || incomingData,
-                directiveSubgraphName: subgraphName,
-            });
+        if (!subscriptionFilters) {
+            return;
+        }
+        // There should only be a single entry in the set
+        const subgraphName = (0, utils_6.getSingleSetEntry)(incomingData.subgraphNames);
+        if (subgraphName === undefined) {
+            this.errors.push((0, errors_1.unknownFieldSubgraphNameError)(incomingData.federatedCoords));
+            return;
         }
+        // @openfed__subscriptionFilter is non-repeatable
+        this.subscriptionFilterDataByFieldPath.set(incomingData.federatedCoords, {
+            directive: subscriptionFilters[0],
+            fieldData: targetData || incomingData,
+            directiveSubgraphName: subgraphName,
+        });
     }
-    federateOutputType({ current, other, hostPath, mostRestrictive }) {
-        other = (0, ast_1.getMutableTypeNode)(other, hostPath, this.errors); // current is already a deep copy
+    federateOutputType({ current, other, coords, mostRestrictive }) {
+        other = (0, ast_1.getMutableTypeNode)(other, coords, this.errors); // current is already a deep copy
         // The first type of the pair to diverge in restriction takes precedence in all future differences.
         // If the other type of the pair also diverges, it's a src error.
         // To keep the output link intact, it is not possible to spread assign "lastTypeNode".
@@ -427,7 +420,7 @@ class FederationFactory {
             }
             if (current.kind === graphql_1.Kind.NON_NULL_TYPE) {
                 if (divergentType === type_merging_1.DivergentType.OTHER) {
-                    this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+                    this.errors.push((0, errors_1.incompatibleChildTypesError)(coords, current.kind, other.kind));
                     return { success: false };
                 }
                 else {
@@ -443,7 +436,7 @@ class FederationFactory {
             }
             if (other.kind === graphql_1.Kind.NON_NULL_TYPE) {
                 if (divergentType === type_merging_1.DivergentType.CURRENT) {
-                    this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+                    this.errors.push((0, errors_1.incompatibleChildTypesError)(coords, current.kind, other.kind));
                     return { success: false };
                 }
                 else {
@@ -458,79 +451,52 @@ class FederationFactory {
                 continue;
             }
             // At least one of the types must be a non-null wrapper, or the types are inconsistent
-            this.errors.push((0, errors_1.incompatibleChildTypesError)(hostPath, current.kind, other.kind));
+            this.errors.push((0, errors_1.incompatibleChildTypesError)(coords, current.kind, other.kind));
             return { success: false };
         }
-        this.errors.push((0, errors_1.maximumTypeNestingExceededError)(hostPath));
+        this.errors.push((0, errors_1.maximumTypeNestingExceededError)(coords));
         return { success: false };
     }
     addSubgraphNameToExistingFieldNamedTypeDisparity(incomingData) {
-        const subgraphNamesByNamedTypeName = this.subgraphNamesByNamedTypeNameByFieldCoordinates.get(`${incomingData.renamedParentTypeName}.${incomingData.name}`);
+        const subgraphNamesByNamedTypeName = this.subgraphNamesByNamedTypeNameByFieldCoords.get(incomingData.federatedCoords);
         if (!subgraphNamesByNamedTypeName) {
             return;
         }
         (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, (0, utils_6.getValueOrDefault)(subgraphNamesByNamedTypeName, incomingData.namedTypeName, () => new Set()));
     }
     upsertFieldData(fieldDataByFieldName, incomingData, isParentInaccessible) {
-        const fieldPath = `${incomingData.renamedParentTypeName}.${incomingData.name}`;
-        (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(fieldPath);
-        this.namedOutputTypeNames.add(incomingData.namedTypeName);
         const existingData = fieldDataByFieldName.get(incomingData.name);
-        const baseData = existingData || incomingData;
-        this.handleSubscriptionFilterDirective(incomingData, fieldPath, baseData);
-        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
-        if (isParentInaccessible || isFieldInaccessible) {
-            this.inaccessiblePaths.add(fieldPath);
-        }
-        this.recordTagNamesByPath(baseData, fieldPath);
+        const targetData = existingData || this.copyFieldData(incomingData, isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(incomingData));
+        (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
+        this.namedOutputTypeNames.add(incomingData.namedTypeName);
+        this.handleSubscriptionFilterDirective(incomingData, targetData);
+        (0, utils_5.extractPersistedDirectives)(targetData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isFieldInaccessible = isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(targetData);
+        if (isFieldInaccessible) {
+            this.inaccessibleCoords.add(targetData.federatedCoords);
+        }
+        this.recordTagNamesByCoords(targetData, targetData.federatedCoords);
         if (!existingData) {
-            incomingData.description = this.getInitialNodeDescription(incomingData);
-            fieldDataByFieldName.set(incomingData.name, incomingData);
-            incomingData.node = {
-                arguments: [],
-                directives: [],
-                kind: incomingData.node.kind,
-                name: (0, utils_1.stringToNameNode)(incomingData.name),
-                type: incomingData.type,
-            };
-            for (const [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
-                inputValueData.description = this.getInitialNodeDescription(inputValueData);
-                inputValueData.node = {
-                    directives: [],
-                    kind: inputValueData.node.kind,
-                    name: (0, utils_1.stringToNameNode)(inputValueData.name),
-                    type: inputValueData.type,
-                };
-                const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
-                this.namedInputValueTypeNames.add(namedArgumentTypeName);
-                (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
-                 ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
-                 ** error. */
-                this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
-                this.recordTagNamesByPath(inputValueData, `${fieldPath}.${argumentName}`);
-            }
+            fieldDataByFieldName.set(targetData.name, targetData);
             return;
         }
         const result = this.federateOutputType({
-            current: existingData.type,
+            current: targetData.type,
             other: incomingData.type,
-            hostPath: fieldPath,
+            coords: targetData.federatedCoords,
             mostRestrictive: false,
         });
         if (result.success) {
-            existingData.type = result.typeNode;
-            if (existingData.namedTypeName !== incomingData.namedTypeName) {
-                const subgraphNamesByNamedTypeName = (0, utils_6.getValueOrDefault)(this.subgraphNamesByNamedTypeNameByFieldCoordinates, `${existingData.renamedParentTypeName}.${existingData.name}`, () => new Map());
+            targetData.type = result.typeNode;
+            if (targetData.namedTypeName !== incomingData.namedTypeName) {
+                const subgraphNamesByNamedTypeName = (0, utils_6.getValueOrDefault)(this.subgraphNamesByNamedTypeNameByFieldCoords, targetData.federatedCoords, () => new Map());
                 /* Only propagate the subgraph names of the existing data if it has never been propagated before.
                  * This is to prevent the propagation of subgraph names where that named type is not returned.
                  */
-                const existingSubgraphNames = (0, utils_6.getValueOrDefault)(subgraphNamesByNamedTypeName, existingData.namedTypeName, () => new Set());
+                const existingSubgraphNames = (0, utils_6.getValueOrDefault)(subgraphNamesByNamedTypeName, targetData.namedTypeName, () => new Set());
                 if (existingSubgraphNames.size < 1) {
                     // Add all subgraph names that are not the subgraph name in the incoming data
-                    for (const subgraphName of existingData.subgraphNames) {
+                    for (const subgraphName of targetData.subgraphNames) {
                         if (!incomingData.subgraphNames.has(subgraphName)) {
                             existingSubgraphNames.add(subgraphName);
                         }
@@ -545,220 +511,348 @@ class FederationFactory {
                 this.addSubgraphNameToExistingFieldNamedTypeDisparity(incomingData);
             }
         }
-        for (const [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
-            const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-            (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
-            this.namedInputValueTypeNames.add(namedArgumentTypeName);
-            /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
-             ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
-             ** error. */
-            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
-            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData, `${fieldPath}.${argumentName}`);
-        }
-        (0, utils_3.addMapEntries)(incomingData.configureDescriptionDataBySubgraphName, existingData.configureDescriptionDataBySubgraphName);
-        (0, utils_5.setLongestDescription)(existingData, incomingData);
-        existingData.isInaccessible ||= incomingData.isInaccessible;
-        (0, utils_3.addMapEntries)(incomingData.externalFieldDataBySubgraphName, existingData.externalFieldDataBySubgraphName);
-        (0, utils_3.addMapEntries)(incomingData.isShareableBySubgraphName, existingData.isShareableBySubgraphName);
-        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+        for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+            this.upsertInputValueData(targetData.argumentDataByArgumentName, inputValueData, targetData.federatedCoords, isFieldInaccessible);
+        }
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.configureDescriptionDataBySubgraphName, existingData.configureDescriptionDataBySubgraphName);
+        (0, utils_5.setLongestDescription)(targetData, incomingData);
+        targetData.isInaccessible ||= incomingData.isInaccessible;
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.externalFieldDataBySubgraphName, targetData.externalFieldDataBySubgraphName);
+        (0, utils_6.addMapEntries)(incomingData.isShareableBySubgraphName, targetData.isShareableBySubgraphName);
+        (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, targetData.subgraphNames);
     }
     getClientSchemaUnionMembers(unionData) {
         const members = [];
         for (const [memberName, namedTypeNode] of unionData.memberByMemberTypeName) {
-            if (!this.inaccessiblePaths.has(memberName)) {
+            if (!this.inaccessibleCoords.has(memberName)) {
                 members.push(namedTypeNode);
             }
         }
         return members;
     }
-    recordTagNamesByPath(data, nodePath) {
-        const path = nodePath || data.name;
-        if (data.persistedDirectivesData.tags.size > 0) {
-            const tagNames = (0, utils_6.getValueOrDefault)(this.tagNamesByPath, path, () => new Set());
-            for (const tagName of data.persistedDirectivesData.tags.keys()) {
-                tagNames.add(tagName);
+    recordTagNamesByCoords(data, coords) {
+        const path = coords || data.name;
+        if (data.persistedDirectivesData.tagDirectiveByName.size < 1) {
+            return;
+        }
+        const tagNames = (0, utils_6.getValueOrDefault)(this.tagNamesByCoords, path, () => new Set());
+        for (const tagName of data.persistedDirectivesData.tagDirectiveByName.keys()) {
+            tagNames.add(tagName);
+        }
+    }
+    copyMutualParentDefinitionData(sourceData) {
+        return {
+            configureDescriptionDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.configureDescriptionDataBySubgraphName),
+            directivesByDirectiveName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByDirectiveName),
+            extensionType: sourceData.extensionType,
+            name: sourceData.name,
+            persistedDirectivesData: (0, utils_5.extractPersistedDirectives)((0, utils_5.newPersistedDirectivesData)(), sourceData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName),
+            description: (0, utils_5.getInitialFederatedDescription)(sourceData),
+        };
+    }
+    copyEnumValueData(sourceData) {
+        return {
+            appearances: sourceData.appearances,
+            configureDescriptionDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.configureDescriptionDataBySubgraphName),
+            federatedCoords: sourceData.federatedCoords,
+            directivesByDirectiveName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByDirectiveName),
+            kind: sourceData.kind,
+            name: sourceData.name,
+            node: {
+                directives: [],
+                kind: sourceData.kind,
+                name: (0, utils_1.stringToNameNode)(sourceData.name),
+            },
+            parentTypeName: sourceData.parentTypeName,
+            persistedDirectivesData: (0, utils_5.extractPersistedDirectives)((0, utils_5.newPersistedDirectivesData)(), sourceData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName),
+            subgraphNames: new Set(sourceData.subgraphNames),
+            description: (0, utils_5.getInitialFederatedDescription)(sourceData),
+        };
+    }
+    copyInputValueData(sourceData) {
+        return {
+            configureDescriptionDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.configureDescriptionDataBySubgraphName),
+            directivesByDirectiveName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByDirectiveName),
+            includeDefaultValue: sourceData.includeDefaultValue,
+            isArgument: sourceData.isArgument,
+            kind: sourceData.kind,
+            name: sourceData.name,
+            namedTypeName: sourceData.namedTypeName,
+            node: {
+                directives: [],
+                kind: graphql_1.Kind.INPUT_VALUE_DEFINITION,
+                name: (0, utils_1.stringToNameNode)(sourceData.name),
+                type: sourceData.type,
+            },
+            originalCoords: sourceData.originalCoords,
+            persistedDirectivesData: (0, utils_5.extractPersistedDirectives)((0, utils_5.newPersistedDirectivesData)(), sourceData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName),
+            federatedCoords: sourceData.federatedCoords,
+            requiredSubgraphNames: new Set(sourceData.requiredSubgraphNames),
+            subgraphNames: new Set(sourceData.subgraphNames),
+            type: sourceData.type,
+            defaultValue: sourceData.defaultValue,
+            description: (0, utils_5.getInitialFederatedDescription)(sourceData),
+        };
+    }
+    copyInputValueDataByValueName(source, isParentInaccessible, parentCoords) {
+        const inputValueDataByInputValueName = new Map();
+        for (const [inputValueName, sourceData] of source) {
+            const targetData = this.copyInputValueData(sourceData);
+            this.handleInputValueInaccessibility(isParentInaccessible, targetData, parentCoords);
+            (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, targetData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
+            this.namedInputValueTypeNames.add(targetData.namedTypeName);
+            this.recordTagNamesByCoords(targetData, `${parentCoords}.${sourceData.name}`);
+            inputValueDataByInputValueName.set(inputValueName, targetData);
+        }
+        return inputValueDataByInputValueName;
+    }
+    copyFieldData(sourceData, isInaccessible) {
+        return {
+            argumentDataByArgumentName: this.copyInputValueDataByValueName(sourceData.argumentDataByArgumentName, isInaccessible, sourceData.federatedCoords),
+            configureDescriptionDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.configureDescriptionDataBySubgraphName),
+            directivesByDirectiveName: (0, utils_6.copyArrayValueMap)(sourceData.directivesByDirectiveName),
+            externalFieldDataBySubgraphName: (0, utils_6.copyObjectValueMap)(sourceData.externalFieldDataBySubgraphName),
+            federatedCoords: sourceData.federatedCoords,
+            isInaccessible: sourceData.isInaccessible,
+            isShareableBySubgraphName: new Map(sourceData.isShareableBySubgraphName),
+            kind: sourceData.kind,
+            name: sourceData.name,
+            namedTypeName: sourceData.namedTypeName,
+            node: {
+                arguments: [],
+                directives: [],
+                kind: sourceData.kind,
+                name: (0, utils_1.stringToNameNode)(sourceData.name),
+                type: sourceData.type,
+            },
+            originalParentTypeName: sourceData.originalParentTypeName,
+            persistedDirectivesData: (0, utils_5.extractPersistedDirectives)((0, utils_5.newPersistedDirectivesData)(), sourceData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName),
+            renamedParentTypeName: sourceData.renamedParentTypeName,
+            subgraphNames: new Set(sourceData.subgraphNames),
+            type: sourceData.type,
+            description: (0, utils_5.getInitialFederatedDescription)(sourceData),
+        };
+    }
+    copyEnumValueDataByValueName(source, isParentInaccessible) {
+        const output = new Map();
+        for (const [childName, sourceData] of source) {
+            const targetData = this.copyEnumValueData(sourceData);
+            this.recordTagNamesByCoords(targetData, targetData.federatedCoords);
+            if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(targetData)) {
+                this.inaccessibleCoords.add(targetData.federatedCoords);
+            }
+            output.set(childName, targetData);
+        }
+        return output;
+    }
+    copyFieldDataByFieldName(source, isParentInaccessible) {
+        const fieldDataByFieldName = new Map();
+        for (const [fieldName, sourceData] of source) {
+            const isFieldInaccessible = isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(sourceData);
+            const targetData = this.copyFieldData(sourceData, isFieldInaccessible);
+            this.handleSubscriptionFilterDirective(targetData);
+            (0, utils_6.getValueOrDefault)(this.coordsByNamedTypeName, targetData.namedTypeName, () => new Set()).add(targetData.federatedCoords);
+            this.namedOutputTypeNames.add(targetData.namedTypeName);
+            this.recordTagNamesByCoords(targetData, targetData.federatedCoords);
+            if (isFieldInaccessible) {
+                this.inaccessibleCoords.add(targetData.federatedCoords);
+            }
+            fieldDataByFieldName.set(fieldName, targetData);
+        }
+        return fieldDataByFieldName;
+    }
+    copyParentDefinitionData(sourceData) {
+        const data = this.copyMutualParentDefinitionData(sourceData);
+        switch (sourceData.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    appearances: sourceData.appearances,
+                    enumValueDataByValueName: this.copyEnumValueDataByValueName(sourceData.enumValueDataByValueName, sourceData.isInaccessible),
+                    isInaccessible: sourceData.isInaccessible,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.name),
+                    },
+                    subgraphNames: new Set(sourceData.subgraphNames),
+                };
+            }
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    inputValueDataByValueName: this.copyInputValueDataByValueName(sourceData.inputValueDataByValueName, sourceData.isInaccessible, sourceData.name),
+                    isInaccessible: sourceData.isInaccessible,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.name),
+                    },
+                    subgraphNames: new Set(sourceData.subgraphNames),
+                };
+            }
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    fieldDataByFieldName: this.copyFieldDataByFieldName(sourceData.fieldDataByFieldName, sourceData.isInaccessible),
+                    implementedInterfaceTypeNames: new Set(sourceData.implementedInterfaceTypeNames),
+                    isEntity: sourceData.isEntity,
+                    isInaccessible: sourceData.isInaccessible,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.name),
+                    },
+                    subgraphNames: new Set(sourceData.subgraphNames),
+                };
+            }
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    fieldDataByFieldName: this.copyFieldDataByFieldName(sourceData.fieldDataByFieldName, sourceData.isInaccessible),
+                    implementedInterfaceTypeNames: new Set(sourceData.implementedInterfaceTypeNames),
+                    isEntity: sourceData.isEntity,
+                    isInaccessible: sourceData.isInaccessible,
+                    isRootType: sourceData.isRootType,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.renamedTypeName || sourceData.name),
+                    },
+                    renamedTypeName: sourceData.renamedTypeName,
+                    subgraphNames: new Set(sourceData.subgraphNames),
+                };
+            }
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.name),
+                    },
+                };
+            }
+            case graphql_1.Kind.UNION_TYPE_DEFINITION: {
+                return {
+                    ...data,
+                    kind: sourceData.kind,
+                    node: {
+                        kind: sourceData.kind,
+                        name: (0, utils_1.stringToNameNode)(sourceData.name),
+                    },
+                    memberByMemberTypeName: new Map(sourceData.memberByMemberTypeName),
+                };
+            }
+        }
+    }
+    getParentTargetData({ existingData, incomingData, }) {
+        if (!existingData) {
+            const targetData = this.copyParentDefinitionData(incomingData);
+            if ((0, utils_5.isParentDataRootType)(targetData)) {
+                targetData.extensionType = types_1.ExtensionType.NONE;
             }
+            return targetData;
         }
+        (0, utils_5.extractPersistedDirectives)(existingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        return existingData;
     }
     upsertParentDefinitionData(incomingData, subgraphName) {
         const entityInterfaceData = this.entityInterfaceFederationDataByTypeName.get(incomingData.name);
         const existingData = this.parentDefinitionDataByTypeName.get(incomingData.name);
-        const baseData = existingData || incomingData;
-        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-        this.recordTagNamesByPath(baseData);
-        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(baseData);
+        const targetData = this.getParentTargetData({ existingData, incomingData });
+        this.recordTagNamesByCoords(targetData);
+        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(targetData);
         if (isParentInaccessible) {
-            this.inaccessiblePaths.add(incomingData.name);
+            this.inaccessibleCoords.add(targetData.name);
         }
         if (entityInterfaceData && entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName)) {
-            incomingData.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
+            targetData.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
+            targetData.node.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
         }
         if (!existingData) {
-            incomingData.description = this.getInitialNodeDescription(incomingData);
-            incomingData.node = {
-                kind: incomingData.kind,
-                name: (0, utils_1.stringToNameNode)(incomingData.name),
-            };
-            this.parentDefinitionDataByTypeName.set(incomingData.name, incomingData);
-            switch (incomingData.kind) {
-                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    for (const [enumValueName, enumValueData] of incomingData.enumValueDataByValueName) {
-                        const enumValuePath = `${incomingData.name}.${enumValueName}`;
-                        enumValueData.description = this.getInitialNodeDescription(enumValueData);
-                        enumValueData.node = {
-                            directives: [],
-                            kind: enumValueData.node.kind,
-                            name: (0, utils_1.stringToNameNode)(enumValueData.name),
-                        };
-                        (0, utils_5.extractPersistedDirectives)(enumValueData.persistedDirectivesData, enumValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                        this.recordTagNamesByPath(enumValueData, enumValuePath);
-                        if ((0, utils_5.isNodeDataInaccessible)(enumValueData)) {
-                            this.inaccessiblePaths.add(enumValuePath);
-                        }
-                    }
-                    return;
-                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    for (const [inputFieldName, inputValueData] of incomingData.inputValueDataByValueName) {
-                        inputValueData.description = this.getInitialNodeDescription(inputValueData);
-                        inputValueData.node = {
-                            directives: [],
-                            kind: inputValueData.node.kind,
-                            name: (0, utils_1.stringToNameNode)(inputValueData.name),
-                            type: inputValueData.type,
-                        };
-                        const namedInputFieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                        (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputValueData.renamedPath);
-                        this.namedInputValueTypeNames.add(namedInputFieldTypeName);
-                        (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                        this.recordTagNamesByPath(inputValueData, `${incomingData.name}.${inputFieldName}`);
-                        if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
-                            this.inaccessiblePaths.add(inputValueData.renamedPath);
-                        }
-                    }
-                    return;
-                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                // intentional fallthrough
-                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    if ((0, utils_5.isParentDataRootType)(incomingData)) {
-                        incomingData.extensionType = types_1.ExtensionType.NONE;
-                    }
-                    for (const [fieldName, fieldData] of incomingData.fieldDataByFieldName) {
-                        fieldData.description = this.getInitialNodeDescription(fieldData);
-                        fieldData.node = {
-                            arguments: [],
-                            directives: [],
-                            kind: fieldData.node.kind,
-                            name: (0, utils_1.stringToNameNode)(fieldData.name),
-                            type: fieldData.type,
-                        };
-                        const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
-                        this.handleSubscriptionFilterDirective(fieldData, fieldPath);
-                        (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
-                        this.namedOutputTypeNames.add(fieldData.namedTypeName);
-                        (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                        this.recordTagNamesByPath(fieldData, fieldPath);
-                        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(fieldData);
-                        if (isParentInaccessible || isFieldInaccessible) {
-                            this.inaccessiblePaths.add(fieldPath);
-                        }
-                        for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
-                            inputValueData.description = this.getInitialNodeDescription(inputValueData);
-                            inputValueData.node = {
-                                directives: [],
-                                kind: inputValueData.node.kind,
-                                name: (0, utils_1.stringToNameNode)(inputValueData.name),
-                                type: inputValueData.type,
-                            };
-                            const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                            (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(inputValueData.renamedPath);
-                            this.namedInputValueTypeNames.add(namedArgumentTypeName);
-                            (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
-                            this.recordTagNamesByPath(inputValueData, `${fieldPath}.${argumentName}`);
-                            /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
-                             ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
-                             ** error. */
-                            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, inputValueData.renamedPath, fieldPath);
-                        }
-                    }
-                    return;
-                default:
-                    // Scalar and Union
-                    return;
-            }
+            this.parentDefinitionDataByTypeName.set(targetData.name, targetData);
+            return;
         }
-        if (existingData.kind !== incomingData.kind) {
+        if (targetData.kind !== incomingData.kind) {
             if (!entityInterfaceData ||
                 !entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName) ||
-                existingData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                targetData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
                 incomingData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                this.errors.push((0, errors_1.incompatibleParentKindMergeError)(existingData.name, (0, utils_6.kindToTypeString)(existingData.kind), (0, utils_6.kindToTypeString)(incomingData.kind)));
+                this.errors.push((0, errors_1.incompatibleParentKindMergeError)(targetData.name, (0, utils_6.kindToTypeString)(targetData.kind), (0, utils_6.kindToTypeString)(incomingData.kind)));
                 return;
             }
         }
-        (0, utils_3.addMapEntries)(incomingData.configureDescriptionDataBySubgraphName, existingData.configureDescriptionDataBySubgraphName);
-        (0, utils_5.setLongestDescription)(existingData, incomingData);
-        (0, utils_5.setParentDataExtensionType)(existingData, incomingData);
-        switch (existingData.kind) {
+        (0, utils_5.extractPersistedDirectives)(targetData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        this.recordTagNamesByCoords(targetData);
+        (0, utils_6.addNewObjectValueMapEntries)(incomingData.configureDescriptionDataBySubgraphName, targetData.configureDescriptionDataBySubgraphName);
+        (0, utils_5.setLongestDescription)(targetData, incomingData);
+        (0, utils_5.setParentDataExtensionType)(targetData, incomingData);
+        switch (targetData.kind) {
             case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                existingData.appearances += 1;
-                (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+                if (!(0, utils_5.areKindsEqual)(targetData, incomingData)) {
+                    return;
+                }
+                targetData.appearances += 1;
+                targetData.isInaccessible ||= isParentInaccessible;
+                (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, targetData.subgraphNames);
                 for (const data of incomingData.enumValueDataByValueName.values()) {
-                    this.upsertEnumValueData(existingData.enumValueDataByValueName, data, isParentInaccessible);
+                    this.upsertEnumValueData(targetData.enumValueDataByValueName, data, isParentInaccessible);
                 }
                 return;
             case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                if (isParentInaccessible && !existingData.isInaccessible) {
-                    this.propagateInaccessibilityToExistingChildren(existingData);
+                if (!(0, utils_5.areKindsEqual)(targetData, incomingData)) {
+                    return;
                 }
-                (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
-                for (const [inputFieldName, inputValueData] of incomingData
-                    .inputValueDataByValueName) {
-                    const inputFieldPath = `${incomingData.name}.${inputFieldName}`;
-                    const namedInputFieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
-                    (0, utils_6.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputFieldPath);
-                    this.namedInputValueTypeNames.add(namedInputFieldTypeName);
-                    this.upsertInputValueData(existingData.inputValueDataByValueName, inputValueData);
-                    this.recordTagNamesByPath(inputValueData, inputFieldPath);
-                    if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
-                        this.inaccessiblePaths.add(inputFieldPath);
-                    }
+                // targetData.isInaccessible currently yields the previous state not the new one.
+                if (isParentInaccessible && !targetData.isInaccessible) {
+                    this.propagateInaccessibilityToExistingChildren(targetData);
+                }
+                targetData.isInaccessible ||= isParentInaccessible;
+                (0, utils_6.addIterableValuesToSet)(incomingData.subgraphNames, targetData.subgraphNames);
+                for (const inputValueData of incomingData.inputValueDataByValueName.values()) {
+                    this.upsertInputValueData(targetData.inputValueDataByValueName, inputValueData, targetData.name, targetData.isInaccessible);
                 }
                 return;
             case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
             // intentional fallthrough
             case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                if (isParentInaccessible && !existingData.isInaccessible) {
-                    this.propagateInaccessibilityToExistingChildren(existingData);
-                }
+                // Not a type guard due to entity interfaces
                 const compositeOutputData = incomingData;
-                (0, utils_6.addIterableValuesToSet)(compositeOutputData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
-                (0, utils_6.addIterableValuesToSet)(compositeOutputData.subgraphNames, existingData.subgraphNames);
+                // targetData.isInaccessible is not yet updated with the newest state
+                if (isParentInaccessible && !targetData.isInaccessible) {
+                    this.propagateInaccessibilityToExistingChildren(targetData);
+                }
+                targetData.isInaccessible ||= isParentInaccessible;
+                (0, utils_6.addIterableValuesToSet)(compositeOutputData.implementedInterfaceTypeNames, targetData.implementedInterfaceTypeNames);
+                (0, utils_6.addIterableValuesToSet)(compositeOutputData.subgraphNames, targetData.subgraphNames);
                 for (const fieldData of compositeOutputData.fieldDataByFieldName.values()) {
-                    this.upsertFieldData(existingData.fieldDataByFieldName, fieldData, isParentInaccessible || existingData.isInaccessible);
+                    this.upsertFieldData(targetData.fieldDataByFieldName, fieldData, targetData.isInaccessible);
                 }
                 return;
             case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                (0, utils_3.addMapEntries)(incomingData.memberByMemberTypeName, existingData.memberByMemberTypeName);
+                if (!(0, utils_5.areKindsEqual)(targetData, incomingData)) {
+                    return;
+                }
+                (0, utils_6.addMapEntries)(incomingData.memberByMemberTypeName, targetData.memberByMemberTypeName);
                 return;
             default:
-                // Scalar type
+                // Scalar
                 return;
         }
     }
     propagateInaccessibilityToExistingChildren(data) {
-        data.isInaccessible = true;
         switch (data.kind) {
             case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                for (const inputFieldName of data.inputValueDataByValueName.keys()) {
-                    this.inaccessiblePaths.add(`${data.name}.${inputFieldName}`);
+                for (const inputFieldData of data.inputValueDataByValueName.values()) {
+                    this.inaccessibleCoords.add(inputFieldData.federatedCoords);
                 }
                 break;
             default:
-                for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
-                    const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
-                    this.inaccessiblePaths.add(fieldPath);
+                for (const fieldData of data.fieldDataByFieldName.values()) {
+                    this.inaccessibleCoords.add(fieldData.federatedCoords);
                     for (const inputValueData of fieldData.argumentDataByArgumentName.values()) {
-                        this.inaccessiblePaths.add(inputValueData.renamedPath);
+                        this.inaccessibleCoords.add(inputValueData.federatedCoords);
                     }
                 }
         }
@@ -773,8 +867,8 @@ class FederationFactory {
             }
             const argumentDataByArgumentName = new Map();
             for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
-                this.namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
-                this.upsertInputValueData(argumentDataByArgumentName, inputValueData);
+                this.namedInputValueTypeNames.add(inputValueData.namedTypeName);
+                this.upsertInputValueData(argumentDataByArgumentName, inputValueData, `@${incomingData.name}`, false);
             }
             this.potentialPersistedDirectiveDefinitionDataByDirectiveName.set(name, {
                 argumentDataByArgumentName,
@@ -799,7 +893,7 @@ class FederationFactory {
         }
         for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
             this.namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
-            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData);
+            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData, `@${existingData.name}`, false);
         }
         (0, utils_5.setLongestDescription)(existingData, incomingData);
         existingData.repeatable &&= incomingData.repeatable;
@@ -831,8 +925,7 @@ class FederationFactory {
         }
     }
     handleDisparateFieldNamedTypes() {
-        for (const [fieldCoordinates, subgraphNamesByNamedTypeName] of this
-            .subgraphNamesByNamedTypeNameByFieldCoordinates) {
+        for (const [fieldCoordinates, subgraphNamesByNamedTypeName] of this.subgraphNamesByNamedTypeNameByFieldCoords) {
             const coordinates = fieldCoordinates.split(string_constants_2.PERIOD);
             if (coordinates.length !== 2) {
                 continue;
@@ -1103,25 +1196,13 @@ class FederationFactory {
         return persistedDirectiveNodes;
     }
     getRouterPersistedDirectiveNodes(nodeData) {
-        const persistedDirectiveNodes = [...nodeData.persistedDirectivesData.tags.values()];
+        const persistedDirectiveNodes = [...nodeData.persistedDirectivesData.tagDirectiveByName.values()];
         if (nodeData.persistedDirectivesData.isDeprecated) {
             persistedDirectiveNodes.push((0, utils_5.generateDeprecatedDirective)(nodeData.persistedDirectivesData.deprecatedReason));
         }
-        persistedDirectiveNodes.push(...this.getValidFlattenedPersistedDirectiveNodeArray(nodeData.persistedDirectivesData.directives, nodeData.name));
+        persistedDirectiveNodes.push(...this.getValidFlattenedPersistedDirectiveNodeArray(nodeData.persistedDirectivesData.directivesByDirectiveName, nodeData.name));
         return persistedDirectiveNodes;
     }
-    getInitialNodeDescription(data) {
-        if (data.configureDescriptionDataBySubgraphName.size < 1) {
-            return data.description;
-        }
-        // Does not loop because the intention is check whether to propagate the first node data description
-        for (const { propagate, description } of data.configureDescriptionDataBySubgraphName.values()) {
-            if (!propagate) {
-                return;
-            }
-            return (0, utils_2.getDescriptionFromString)(description) || data.description;
-        }
-    }
     getFederatedGraphNodeDescription(data) {
         if (data.configureDescriptionDataBySubgraphName.size < 1) {
             return data.description;
@@ -1183,7 +1264,7 @@ class FederationFactory {
         }
         else if (argumentNames.length > 0) {
             // fieldConfiguration might already exist through subscriptionFilter
-            (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldPath, fieldPath, () => ({
+            (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldPath, () => ({
                 argumentNames,
                 fieldName: fieldData.name,
                 typeName: fieldData.renamedParentTypeName,
@@ -1417,7 +1498,7 @@ class FederationFactory {
             }
             const clientInterfaces = [];
             for (const interfaceTypeName of data.implementedInterfaceTypeNames) {
-                if (!this.inaccessiblePaths.has(interfaceTypeName)) {
+                if (!this.inaccessibleCoords.has(interfaceTypeName)) {
                     clientInterfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceTypeName));
                 }
             }
@@ -1459,7 +1540,7 @@ class FederationFactory {
         const segments = coordinates.split(string_constants_2.PERIOD);
         let segment = segments[0];
         for (let i = 0; i < segments.length; i++) {
-            if (this.inaccessiblePaths.has(segment)) {
+            if (this.inaccessibleCoords.has(segment)) {
                 return true;
             }
             segment += `.${segments[i + 1]}`;
@@ -1467,21 +1548,21 @@ class FederationFactory {
         return false;
     }
     validateReferencesOfInaccessibleType(data) {
-        const paths = this.pathsByNamedTypeName.get(data.name);
-        if (!paths || paths.size < 1) {
+        const allCoords = this.coordsByNamedTypeName.get(data.name);
+        if (!allCoords || allCoords.size < 1) {
             return;
         }
-        const invalidPaths = [];
-        for (const path of paths) {
-            if (this.inaccessiblePaths.has(path)) {
+        const invalidCoords = [];
+        for (const coords of allCoords) {
+            if (this.inaccessibleCoords.has(coords)) {
                 continue;
             }
-            if (!this.validatePathSegmentInaccessibility(path)) {
-                invalidPaths.push(path);
+            if (!this.validatePathSegmentInaccessibility(coords)) {
+                invalidCoords.push(coords);
             }
         }
-        if (invalidPaths.length > 0) {
-            this.errors.push((0, errors_1.invalidReferencesOfInaccessibleTypeError)((0, utils_6.kindToTypeString)(data.kind), data.name, invalidPaths));
+        if (invalidCoords.length > 0) {
+            this.errors.push((0, errors_1.invalidReferencesOfInaccessibleTypeError)((0, utils_6.kindToTypeString)(data.kind), data.name, invalidCoords));
         }
     }
     validateQueryRootType() {
@@ -1504,7 +1585,7 @@ class FederationFactory {
             return [];
         }
         let lastData = objectData;
-        if (this.inaccessiblePaths.has(lastData.renamedTypeName)) {
+        if (this.inaccessibleCoords.has(lastData.renamedTypeName)) {
             fieldErrorMessages.push((0, errors_1.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, paths[0], lastData.renamedTypeName));
             return [];
         }
@@ -1526,7 +1607,7 @@ class FederationFactory {
                 fieldErrorMessages.push((0, errors_1.invalidSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath, fieldPath, directiveSubgraphName));
                 return [];
             }
-            if (this.inaccessiblePaths.has(fieldPath)) {
+            if (this.inaccessibleCoords.has(fieldPath)) {
                 fieldErrorMessages.push((0, errors_1.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath, fieldPath));
                 return [];
             }
@@ -1738,7 +1819,7 @@ class FederationFactory {
             this.isMaxDepth = false;
             return;
         }
-        (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldPath, fieldPath, () => ({
+        (0, utils_6.getValueOrDefault)(this.fieldConfigurationByFieldCoords, fieldPath, () => ({
             argumentNames: [],
             fieldName,
             typeName: parentTypeName,
@@ -1746,7 +1827,7 @@ class FederationFactory {
     }
     validateSubscriptionFiltersAndGenerateConfiguration() {
         for (const [fieldPath, data] of this.subscriptionFilterDataByFieldPath) {
-            if (this.inaccessiblePaths.has(fieldPath)) {
+            if (this.inaccessibleCoords.has(fieldPath)) {
                 continue;
             }
             const namedTypeData = this.parentDefinitionDataByTypeName.get(data.fieldData.namedTypeName);
@@ -1784,6 +1865,13 @@ class FederationFactory {
         this.pushParentDefinitionDataToDocumentDefinitions(definitionsWithInterfaces);
         this.validateInterfaceImplementationsAndPushToDocumentDefinitions(definitionsWithInterfaces);
         this.validateQueryRootType();
+        /*
+         * If an input value (field or argument) is declared @inaccessible but its parent is not, it is an error.
+         * However, this state can only be known after all subgraphs have been federated.
+         */
+        for (const err of this.inaccessibleRequiredInputValueErrorByCoords.values()) {
+            this.errors.push(err);
+        }
         // Return any composition errors before checking whether all fields are resolvable
         if (this.errors.length > 0) {
             return { errors: this.errors, success: false, warnings: this.warnings };
@@ -1813,14 +1901,15 @@ class FederationFactory {
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphConfigBySubgraphName.set(subgraph.name, {
                 configurationDataByTypeName: subgraph.configurationDataByTypeName,
+                parentDefinitionDataByTypeName: subgraph.parentDefinitionDataByTypeName,
                 schema: subgraph.schema,
             });
         }
         for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
-            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldCoords, authorizationData);
         }
         return {
-            fieldConfigurations: Array.from(this.fieldConfigurationByFieldPath.values()),
+            fieldConfigurations: Array.from(this.fieldConfigurationByFieldCoords.values()),
             subgraphConfigBySubgraphName,
             federatedGraphAST: newRouterAST,
             federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST, { assumeValid: true, assumeValidSDL: true }),
@@ -1833,7 +1922,7 @@ class FederationFactory {
     }
     getClientSchemaObjectBoolean() {
         // If the schema does not implement @tag nor @inaccessible, an empty object will be spread
-        if (this.inaccessiblePaths.size < 1 && this.tagNamesByPath.size < 1) {
+        if (this.inaccessibleCoords.size < 1 && this.tagNamesByCoords.size < 1) {
             return {};
         }
         // otherwise, the object is spread in as true
@@ -1848,18 +1937,18 @@ class FederationFactory {
                 continue;
             }
             if (!tagNames.isDisjointFrom(childTagData.tagNames)) {
-                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directives, string_constants_2.INACCESSIBLE, () => [
+                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directivesByDirectiveName, string_constants_2.INACCESSIBLE, () => [
                     (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                 ]);
-                this.inaccessiblePaths.add(`${parentDefinitionData.name}.${childName}`);
+                this.inaccessibleCoords.add(`${parentDefinitionData.name}.${childName}`);
                 accessibleChildren -= 1;
             }
         }
         if (accessibleChildren < 1) {
-            parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+            parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                 (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
             ]);
-            this.inaccessiblePaths.add(parentDefinitionData.name);
+            this.inaccessibleCoords.add(parentDefinitionData.name);
         }
     }
     handleChildTagInclusions(parentDefinitionData, children, childTagDataByChildName, tagNames) {
@@ -1871,18 +1960,18 @@ class FederationFactory {
             }
             const childTagData = childTagDataByChildName.get(childName);
             if (!childTagData || tagNames.isDisjointFrom(childTagData.tagNames)) {
-                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directives, string_constants_2.INACCESSIBLE, () => [
+                (0, utils_6.getValueOrDefault)(childData.persistedDirectivesData.directivesByDirectiveName, string_constants_2.INACCESSIBLE, () => [
                     (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                 ]);
-                this.inaccessiblePaths.add(`${parentDefinitionData.name}.${childName}`);
+                this.inaccessibleCoords.add(`${parentDefinitionData.name}.${childName}`);
                 accessibleChildren -= 1;
             }
         }
         if (accessibleChildren < 1) {
-            parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+            parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                 (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
             ]);
-            this.inaccessiblePaths.add(parentDefinitionData.name);
+            this.inaccessibleCoords.add(parentDefinitionData.name);
         }
     }
     buildFederationContractResult(contractTagOptions) {
@@ -1898,10 +1987,10 @@ class FederationFactory {
                     continue;
                 }
                 if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(parentTagData.tagNames)) {
-                    parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+                    parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                     ]);
-                    this.inaccessiblePaths.add(parentTypeName);
+                    this.inaccessibleCoords.add(parentTypeName);
                     // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
@@ -1928,10 +2017,10 @@ class FederationFactory {
                                 continue;
                             }
                             if (!contractTagOptions.tagNamesToExclude.isDisjointFrom(childTagData.tagNames)) {
-                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directives, string_constants_2.INACCESSIBLE, () => [
+                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directivesByDirectiveName, string_constants_2.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                                 ]);
-                                this.inaccessiblePaths.add(`${parentTypeName}.${fieldName}`);
+                                this.inaccessibleCoords.add(fieldData.federatedCoords);
                                 accessibleFields -= 1;
                                 continue;
                             }
@@ -1941,18 +2030,16 @@ class FederationFactory {
                                     continue;
                                 }
                                 if (!tagNames.isDisjointFrom(tagNames)) {
-                                    (0, utils_6.getValueOrDefault)(inputValueData.persistedDirectivesData.directives, string_constants_2.INACCESSIBLE, () => [
-                                        (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
-                                    ]);
-                                    this.inaccessiblePaths.add(inputValueData.renamedPath);
+                                    (0, utils_6.getValueOrDefault)(inputValueData.persistedDirectivesData.directivesByDirectiveName, string_constants_2.INACCESSIBLE, () => [(0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE)]);
+                                    this.inaccessibleCoords.add(inputValueData.federatedCoords);
                                 }
                             }
                         }
                         if (accessibleFields < 1) {
-                            parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+                            parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                                 (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                             ]);
-                            this.inaccessiblePaths.add(parentTypeName);
+                            this.inaccessibleCoords.add(parentTypeName);
                         }
                 }
             }
@@ -1964,10 +2051,10 @@ class FederationFactory {
                 }
                 const parentTagData = this.parentTagDataByTypeName.get(parentTypeName);
                 if (!parentTagData) {
-                    parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+                    parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                     ]);
-                    this.inaccessiblePaths.add(parentTypeName);
+                    this.inaccessibleCoords.add(parentTypeName);
                     // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
@@ -1975,10 +2062,10 @@ class FederationFactory {
                     continue;
                 }
                 if (parentTagData.childTagDataByChildName.size < 1) {
-                    parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+                    parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                         (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                     ]);
-                    this.inaccessiblePaths.add(parentTypeName);
+                    this.inaccessibleCoords.add(parentTypeName);
                     // If the parent is inaccessible, there is no need to assess further
                     continue;
                 }
@@ -2002,18 +2089,18 @@ class FederationFactory {
                             }
                             const childTagData = parentTagData.childTagDataByChildName.get(fieldName);
                             if (!childTagData || contractTagOptions.tagNamesToInclude.isDisjointFrom(childTagData.tagNames)) {
-                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directives, string_constants_2.INACCESSIBLE, () => [
+                                (0, utils_6.getValueOrDefault)(fieldData.persistedDirectivesData.directivesByDirectiveName, string_constants_2.INACCESSIBLE, () => [
                                     (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                                 ]);
-                                this.inaccessiblePaths.add(`${parentTypeName}.${fieldName}`);
+                                this.inaccessibleCoords.add(fieldData.federatedCoords);
                                 accessibleFields -= 1;
                             }
                         }
                         if (accessibleFields < 1) {
-                            parentDefinitionData.persistedDirectivesData.directives.set(string_constants_2.INACCESSIBLE, [
+                            parentDefinitionData.persistedDirectivesData.directivesByDirectiveName.set(string_constants_2.INACCESSIBLE, [
                                 (0, utils_6.generateSimpleDirective)(string_constants_2.INACCESSIBLE),
                             ]);
-                            this.inaccessiblePaths.add(parentTypeName);
+                            this.inaccessibleCoords.add(parentTypeName);
                         }
                 }
             }
@@ -2043,14 +2130,15 @@ class FederationFactory {
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphConfigBySubgraphName.set(subgraph.name, {
                 configurationDataByTypeName: subgraph.configurationDataByTypeName,
+                parentDefinitionDataByTypeName: subgraph.parentDefinitionDataByTypeName,
                 schema: subgraph.schema,
             });
         }
         for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
-            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldCoords, authorizationData);
         }
         return {
-            fieldConfigurations: Array.from(this.fieldConfigurationByFieldPath.values()),
+            fieldConfigurations: Array.from(this.fieldConfigurationByFieldCoords.values()),
             subgraphConfigBySubgraphName,
             federatedGraphAST: newRouterAST,
             federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST, { assumeValid: true, assumeValidSDL: true }),