@wundergraph/composition 0.18.4 → 0.19.0

package/dist/federation/federation-factory.js

@@ -1,43 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.federateSubgraphs = exports.FederationFactory = void 0;
-const graphology_1 = require("graphology");
 const graphql_1 = require("graphql");
-const ast_1 = require("../ast/ast");
+const ast_1 = require("../schema-building/ast");
 const utils_1 = require("../ast/utils");
 const errors_1 = require("../errors/errors");
-const type_merging_1 = require("../schema-building/type-merging");
-const utils_2 = require("./utils");
-const subgraph_1 = require("../subgraph/subgraph");
 const string_constants_1 = require("../utils/string-constants");
-const utils_3 = require("../utils/utils");
+const utils_2 = require("../utils/utils");
 const merge_1 = require("@graphql-tools/merge");
 const constants_1 = require("../utils/constants");
 const normalization_factory_1 = require("../normalization/normalization-factory");
-const utils_4 = require("../normalization/utils");
+const utils_3 = require("../normalization/utils");
+const utils_4 = require("../schema-building/utils");
+const walkers_1 = require("./walkers");
 class FederationFactory {
     authorizationDataByParentTypeName;
-    abstractToConcreteTypeNames = new Map();
     areFieldsExternal = false;
     areFieldsShareable = false;
-    argumentTypeNameSet = new Set();
+    concreteTypeNamesByAbstractTypeName;
     fieldConfigurationByFieldPath = new Map();
+    namedInputValueTypeNames = new Set();
+    namedOutputTypeNames = new Set();
     entityInterfaceFederationDataByTypeName;
     executableDirectives = new Set();
     parentTypeName = '';
-    persistedDirectives = new Set([string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG]);
     persistedDirectiveDefinitions = new Set([string_constants_1.AUTHENTICATED, string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG, string_constants_1.REQUIRES_SCOPES]);
     currentSubgraphName = '';
     childName = '';
-    directiveDefinitions = new Map();
     entityContainersByTypeName;
     errors = [];
     evaluatedObjectLikesBySubgraph = new Map();
-    extensions = new Map();
-    graph = new graphology_1.MultiGraph();
+    graph;
     graphEdges = new Set();
     graphPaths = new Map();
-    inputFieldTypeNameSet = new Set();
     invalidOrScopesHostPaths = new Set();
     isCurrentParentEntity = false;
     isCurrentParentInterface = false;
@@ -45,595 +40,54 @@ class FederationFactory {
     isCurrentParentExtensionType = false;
     isParentRootType = false;
     isParentInputObject = false;
-    keyFieldNamesByParentTypeName = new Map();
-    outputFieldTypeNameSet = new Set();
-    parents = new Map();
+    outputFieldTypeNames = new Set();
+    parentDefinitionDataByTypeName = new Map();
+    objectExtensionDataByTypeName = new Map();
+    persistedDirectiveDefinitionByDirectiveName = new Map([
+        [string_constants_1.AUTHENTICATED, constants_1.AUTHENTICATED_DEFINITION],
+        [string_constants_1.DEPRECATED, constants_1.DEPRECATED_DEFINITION],
+        [string_constants_1.INACCESSIBLE, constants_1.INACCESSIBLE_DEFINITION],
+        [string_constants_1.REQUIRES_SCOPES, constants_1.REQUIRES_SCOPES_DEFINITION],
+        [string_constants_1.TAG, constants_1.TAG_DEFINITION],
+    ]);
     rootTypeNames = new Set([string_constants_1.DEFAULT_MUTATION, string_constants_1.DEFAULT_QUERY, string_constants_1.DEFAULT_SUBSCRIPTION]);
     internalSubgraphBySubgraphName;
     shareableErrorTypeNames = new Map();
-    renamedTypeNameByOriginalTypeName = new Map();
     warnings;
-    constructor(authorizationDataByParentTypeName, entityContainersByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings) {
+    constructor(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainersByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings) {
         this.authorizationDataByParentTypeName = authorizationDataByParentTypeName;
+        this.concreteTypeNamesByAbstractTypeName = concreteTypeNamesByAbstractTypeName;
         this.entityContainersByTypeName = entityContainersByTypeName;
         this.entityInterfaceFederationDataByTypeName = entityInterfaceFederationDataByTypeName;
+        this.graph = graph;
         this.internalSubgraphBySubgraphName = internalSubgraphBySubgraphName;
         this.warnings = warnings || [];
     }
-    isObjectRootType(node) {
-        return this.rootTypeNames.has(node.name.value);
-    }
-    populateMultiGraphAndRenameOperations(subgraphs) {
-        for (const subgraph of subgraphs.values()) {
-            this.currentSubgraphName = subgraph.name;
-            (0, subgraph_1.walkSubgraphToCollectObjectLikesAndDirectiveDefinitions)(this, subgraph);
-        }
-    }
-    getEnumMergeMethod(enumName) {
-        if (this.inputFieldTypeNameSet.has(enumName) || this.argumentTypeNameSet.has(enumName)) {
-            if (this.outputFieldTypeNameSet.has(enumName)) {
-                return utils_2.MergeMethod.CONSISTENT;
-            }
-            return utils_2.MergeMethod.INTERSECTION;
-        }
-        return utils_2.MergeMethod.UNION;
-    }
-    validateArgumentDefaultValues(argName, existingDefaultValue, newDefaultValue) {
-        if (existingDefaultValue.kind !== newDefaultValue.kind) {
-            // This should be caught by subgraph validation
-            this.errors.push((0, errors_1.incompatibleArgumentDefaultValueTypeError)(argName, this.parentTypeName, this.childName, existingDefaultValue.kind, newDefaultValue.kind));
-        }
-        if ('value' in newDefaultValue && existingDefaultValue.value !== newDefaultValue.value) {
-            this.errors.push((0, errors_1.incompatibleArgumentDefaultValueError)(argName, this.parentTypeName, this.childName, existingDefaultValue.value, newDefaultValue.value));
-        }
-    }
-    compareAndValidateArgumentDefaultValues(existingArg, newArg) {
-        const newDefaultValue = newArg.defaultValue;
-        existingArg.node.defaultValue = existingArg.node.defaultValue || newDefaultValue;
-        if (!existingArg.node.defaultValue || !newDefaultValue) {
-            existingArg.includeDefaultValue = false;
-            return;
-        }
-        const argumentName = existingArg.node.name.value;
-        const existingDefaultValue = existingArg.node.defaultValue;
-        switch (existingDefaultValue.kind) {
-            case graphql_1.Kind.LIST: // TODO
-                break;
-            case graphql_1.Kind.NULL:
-                break;
-            case graphql_1.Kind.OBJECT:
-                break;
-            // BOOLEAN, ENUM, FLOAT, INT, and STRING intentionally fall through
-            case graphql_1.Kind.BOOLEAN:
-            case graphql_1.Kind.ENUM:
-            case graphql_1.Kind.FLOAT:
-            case graphql_1.Kind.INT:
-            case graphql_1.Kind.STRING:
-                this.validateArgumentDefaultValues(argumentName, existingDefaultValue, newDefaultValue);
-                break;
-            default:
-                throw (0, errors_1.unexpectedArgumentKindFatalError)(argumentName, this.childName);
-        }
-    }
-    upsertRequiredSubgraph(set, isRequired) {
-        if (isRequired) {
-            set.add(this.currentSubgraphName);
-        }
-        return set;
-    }
-    upsertExtensionPersistedDirectives(extensionDirectives, baseDirectives) {
-        // Add unique tag directives
-        for (const [tagValue, tagDirectiveNode] of extensionDirectives.tags) {
-            baseDirectives.tags.set(tagValue, tagDirectiveNode);
-        }
-        // Push other directives
-        for (const [directiveName, directiveNodes] of extensionDirectives.directives) {
-            const existingDirectives = baseDirectives.directives.get(directiveName);
-            if (!existingDirectives) {
-                baseDirectives.directives.set(directiveName, directiveNodes);
-                continue;
-            }
-            existingDirectives.push(...directiveNodes);
-        }
-        // If the extension has no deprecated directive, there's nothing further to do
-        const extensionDeprecatedDirective = extensionDirectives.deprecated.directive;
-        const extensionDeprecatedReason = extensionDirectives.deprecated.reason;
-        if (!extensionDeprecatedDirective || !extensionDeprecatedReason) {
-            return;
-        }
-        // If there is no reason or the existing reason is longer, return
-        if (baseDirectives.deprecated.directive &&
-            baseDirectives.deprecated.reason &&
-            extensionDeprecatedReason.length < baseDirectives.deprecated.reason.length) {
-            return;
-        }
-        // Only update if the new reason is longer
-        baseDirectives.deprecated.directive = extensionDeprecatedDirective;
-        baseDirectives.deprecated.reason = extensionDeprecatedReason;
-    }
-    upsertExtensionFieldArguments(extensionFieldArguments, baseFieldArguments) {
-        for (const [argumentName, extensionArgumentContainer] of extensionFieldArguments) {
-            const existingArgumentContainer = baseFieldArguments.get(argumentName);
-            if (!existingArgumentContainer) {
-                // If the argument doesn't exist on the base field, simply add it
-                baseFieldArguments.set(argumentName, extensionArgumentContainer);
-                continue;
-            }
-            if (extensionArgumentContainer.requiredSubgraphs.size > 0) {
-                // If the argument is required on any extensions, add it to the base requiredSubgraphs set
-                (0, utils_3.addIterableValuesToSet)(extensionArgumentContainer.requiredSubgraphs, existingArgumentContainer.requiredSubgraphs);
-            }
-            // Add the subgraphs in which the extensions' arguments are found to the base subgraphs set
-            (0, utils_3.addIterableValuesToSet)(extensionArgumentContainer.subgraphs, existingArgumentContainer.subgraphs);
-            // Set the most restrictive type for the argument
-            const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingArgumentContainer.node.type, extensionArgumentContainer.node.type, this.childName, argumentName);
-            if (typeNode) {
-                existingArgumentContainer.node.type = typeNode;
-            }
-            else {
-                if (!typeErrors || typeErrors.length < 2) {
-                    throw (0, errors_1.argumentTypeMergeFatalError)(argumentName, this.childName);
-                }
-                this.errors.push((0, errors_1.incompatibleArgumentTypesError)(argumentName, this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
-            }
-            this.compareAndValidateArgumentDefaultValues(existingArgumentContainer, extensionArgumentContainer.node);
-            this.upsertExtensionPersistedDirectives(extensionArgumentContainer.directives, existingArgumentContainer.directives);
-        }
-    }
-    // TODO validation of default values
-    upsertArguments(node, argumentMap) {
-        if (!node.arguments) {
-            return argumentMap;
-        }
-        for (const argumentNode of node.arguments) {
-            const argName = argumentNode.name.value;
-            const argPath = `${node.name.value}(${argName}...)`;
-            this.argumentTypeNameSet.add((0, type_merging_1.getNamedTypeForChild)(argPath, argumentNode.type));
-            const isRequired = (0, type_merging_1.isTypeRequired)(argumentNode.type);
-            const existingArgumentContainer = argumentMap.get(argName);
-            if (!existingArgumentContainer) {
-                argumentMap.set(argName, {
-                    directives: this.extractPersistedDirectives(argumentNode.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    includeDefaultValue: !!argumentNode.defaultValue,
-                    node: (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.childName),
-                    requiredSubgraphs: this.upsertRequiredSubgraph(new Set(), isRequired),
-                    subgraphs: new Set([this.currentSubgraphName]),
-                });
-                continue;
-            }
-            this.extractPersistedDirectives(argumentNode.directives || [], existingArgumentContainer.directives);
-            (0, utils_1.setLongestDescriptionForNode)(existingArgumentContainer.node, argumentNode.description);
-            this.upsertRequiredSubgraph(existingArgumentContainer.requiredSubgraphs, isRequired);
-            existingArgumentContainer.subgraphs.add(this.currentSubgraphName);
-            const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingArgumentContainer.node.type, argumentNode.type, this.childName, argName);
-            if (typeNode) {
-                existingArgumentContainer.node.type = typeNode;
-            }
-            else {
-                if (!typeErrors || typeErrors.length < 2) {
-                    throw (0, errors_1.argumentTypeMergeFatalError)(argName, this.childName);
-                }
-                this.errors.push((0, errors_1.incompatibleArgumentTypesError)(argName, this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
-            }
-            this.compareAndValidateArgumentDefaultValues(existingArgumentContainer, argumentNode);
-        }
-        return argumentMap;
-    }
-    isFieldEntityKey() {
-        const parent = this.keyFieldNamesByParentTypeName.get(this.parentTypeName);
-        if (parent) {
-            return parent.has(this.childName);
-        }
-        return false;
-    }
-    isFieldExternal(node) {
-        return this.areFieldsExternal || (0, utils_1.isNodeExternal)(node);
-    }
-    isFieldShareable(node) {
-        return (!this.isCurrentSubgraphVersionTwo || this.areFieldsShareable || this.isFieldEntityKey() || (0, utils_1.isNodeShareable)(node));
-    }
-    upsertDirectiveNode(node) {
-        const directiveName = node.name.value;
-        const directiveDefinition = this.directiveDefinitions.get(directiveName);
-        if (directiveDefinition) {
-            if (!this.executableDirectives.has(directiveName)) {
-                return;
-            }
-            if ((0, utils_1.mergeExecutableDirectiveLocations)(node.locations, directiveDefinition).size < 1) {
-                this.executableDirectives.delete(directiveName);
-                return;
-            }
-            this.upsertArguments(node, directiveDefinition.arguments);
-            (0, utils_1.setLongestDescriptionForNode)(directiveDefinition.node, node.description);
-            directiveDefinition.node.repeatable = directiveDefinition.node.repeatable && node.repeatable;
-            directiveDefinition.subgraphNames.add(this.currentSubgraphName);
-            return;
-        }
-        const executableLocations = (0, utils_1.extractExecutableDirectiveLocations)(node.locations, new Set());
-        this.directiveDefinitions.set(directiveName, {
-            arguments: this.upsertArguments(node, new Map()),
-            executableLocations,
-            node: (0, ast_1.directiveDefinitionNodeToMutable)(node),
-            subgraphNames: new Set([this.currentSubgraphName]),
-        });
-        if (executableLocations.size > 0) {
-            this.executableDirectives.add(directiveName);
-        }
-    }
-    isShareabilityOfAllFieldInstancesValid(fieldContainer) {
-        let shareableFields = 0;
-        let unshareableFields = 0;
-        for (const [subgraphName, isShareable] of fieldContainer.subgraphsByShareable) {
-            /*
-              shareability is ignored if:
-              1. the field is external
-              2. the field is overridden by another subgraph (in which case it has not been upserted)
-             */
-            if (fieldContainer.subgraphsByExternal.get(subgraphName)) {
-                continue;
-            }
-            if (isShareable) {
-                if (unshareableFields) {
-                    return false;
-                }
-                shareableFields += 1;
-                continue;
-            }
-            unshareableFields += 1;
-            if (shareableFields || unshareableFields > 1) {
-                return false;
-            }
-        }
-        return true;
-    }
-    upsertFieldNode(node) {
-        const parent = this.isCurrentParentExtensionType
-            ? (0, utils_3.getOrThrowError)(this.extensions, this.parentTypeName, string_constants_1.EXTENSIONS)
-            : (0, utils_3.getOrThrowError)(this.parents, this.parentTypeName, string_constants_1.PARENTS);
-        if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
-            parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
-            parent.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-            throw (0, errors_1.unexpectedKindFatalError)(this.parentTypeName);
-        }
-        const fieldMap = parent.fields;
-        const isFieldExternal = this.isFieldExternal(node);
-        const isFieldShareable = this.isFieldShareable(node);
-        const fieldPath = `${this.parentTypeName}.${this.childName}`;
-        const fieldRootTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
-        const existingFieldContainer = fieldMap.get(this.childName);
-        if (existingFieldContainer) {
-            this.extractPersistedDirectives(node.directives || [], existingFieldContainer.directives);
-            (0, utils_1.setLongestDescriptionForNode)(existingFieldContainer.node, node.description);
-            existingFieldContainer.subgraphNames.add(this.currentSubgraphName);
-            existingFieldContainer.subgraphsByShareable.set(this.currentSubgraphName, isFieldShareable);
-            existingFieldContainer.subgraphsByExternal.set(this.currentSubgraphName, isFieldExternal);
-            const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingFieldContainer.node.type, node.type, this.parentTypeName, this.childName);
-            if (typeNode) {
-                existingFieldContainer.node.type = typeNode;
-            }
-            else {
-                if (!typeErrors || typeErrors.length < 2) {
-                    throw (0, errors_1.fieldTypeMergeFatalError)(this.childName);
-                }
-                this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
-            }
-            this.upsertArguments(node, existingFieldContainer.arguments);
-            /* A field is valid if one of the following is true:
-              1. The field is an interface
-              2. The field is external
-              3. Non-external fields are ALL shareable
-              4. All other fields besides the current field are external
-            */
-            if (this.isCurrentParentInterface ||
-                isFieldExternal ||
-                (existingFieldContainer.isShareable && isFieldShareable) ||
-                this.isShareabilityOfAllFieldInstancesValid(existingFieldContainer) ||
-                this.entityInterfaceFederationDataByTypeName.has(this.parentTypeName) // TODO handle shareability with interfaceObjects
-            ) {
-                return;
-            }
-            const shareableErrorTypeNames = this.shareableErrorTypeNames.get(this.parentTypeName);
-            if (shareableErrorTypeNames) {
-                shareableErrorTypeNames.add(this.childName);
-            }
-            else {
-                this.shareableErrorTypeNames.set(this.parentTypeName, new Set([this.childName]));
-            }
-            return;
-        }
-        this.outputFieldTypeNameSet.add(fieldRootTypeName);
-        fieldMap.set(this.childName, {
-            arguments: this.upsertArguments(node, new Map()),
-            directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-            isShareable: isFieldShareable,
-            node: (0, ast_1.fieldDefinitionNodeToMutable)(node, this.parentTypeName),
-            namedTypeName: fieldRootTypeName,
-            subgraphNames: new Set([this.currentSubgraphName]),
-            subgraphsByShareable: new Map([[this.currentSubgraphName, isFieldShareable]]),
-            subgraphsByExternal: new Map([[this.currentSubgraphName, isFieldExternal]]),
-        });
-    }
-    upsertValueNode(node) {
-        const parent = this.parents.get(this.parentTypeName);
-        switch (node.kind) {
-            case graphql_1.Kind.ENUM_VALUE_DEFINITION:
-                if (!parent) {
-                    // This should never happen
-                    throw (0, errors_1.federationInvalidParentTypeError)(this.parentTypeName, this.childName);
-                }
-                if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
-                    throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.ENUM_TYPE_DEFINITION, parent.kind);
-                }
-                const enumValues = parent.values;
-                const enumValueContainer = enumValues.get(this.childName);
-                if (enumValueContainer) {
-                    this.extractPersistedDirectives(node.directives || [], enumValueContainer.directives);
-                    (0, utils_1.setLongestDescriptionForNode)(enumValueContainer.node, node.description);
-                    enumValueContainer.appearances += 1;
-                    return;
-                }
-                enumValues.set(this.childName, {
-                    appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    node: (0, ast_1.enumValueDefinitionNodeToMutable)(node),
-                });
-                return;
-            case graphql_1.Kind.INPUT_VALUE_DEFINITION:
-                if (!parent || !this.isParentInputObject) {
-                    // these are arguments to a directive
-                    return;
-                }
-                if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
-                    throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION, parent.kind);
-                }
-                const inputValues = parent.fields;
-                const inputValueContainer = inputValues.get(this.childName);
-                if (inputValueContainer) {
-                    this.extractPersistedDirectives(node.directives || [], inputValueContainer.directives);
-                    inputValueContainer.appearances += 1;
-                    (0, utils_1.setLongestDescriptionForNode)(inputValueContainer.node, node.description);
-                    const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(inputValueContainer.node.type, node.type, this.parentTypeName, this.childName);
-                    if (typeNode) {
-                        inputValueContainer.node.type = typeNode;
-                    }
-                    else {
-                        if (!typeErrors || typeErrors.length < 2) {
-                            throw (0, errors_1.fieldTypeMergeFatalError)(this.childName);
-                        }
-                        this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
-                    }
-                    return;
-                }
-                const valuePath = `${this.parentTypeName}.${this.childName}`;
-                const inputValueNamedType = (0, type_merging_1.getNamedTypeForChild)(valuePath, node.type);
-                this.inputFieldTypeNameSet.add(inputValueNamedType);
-                inputValues.set(this.childName, {
-                    appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    includeDefaultValue: !!node.defaultValue,
-                    node: (0, ast_1.inputValueDefinitionNodeToMutable)(node, this.parentTypeName),
-                });
-                return;
-            default:
-                throw (0, errors_1.unexpectedKindFatalError)(this.childName);
-        }
-    }
-    upsertInterfaceObjectParentNode(node) {
-        const parentTypeName = node.name.value;
-        const parent = this.parents.get(parentTypeName);
-        if (parent) {
-            if (parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
-                throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-            }
-            (0, utils_1.setLongestDescriptionForNode)(parent.node, node.description);
-            this.extractPersistedDirectives(node.directives || [], parent.directives);
-            (0, utils_1.extractInterfaces)(node, parent.interfaces);
-            parent.subgraphNames.add(this.currentSubgraphName);
-            return;
-        }
-        this.parents.set(parentTypeName, {
-            directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-            fields: new Map(),
-            interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
-            kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
-            node: (0, ast_1.interfaceTypeDefinitionNodeToMutable)({
-                ...node,
-                kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
-            }),
-            subgraphNames: new Set([this.currentSubgraphName]),
-        });
-    }
-    upsertParentNode(node) {
-        const parentTypeName = node.name.value;
-        const parent = this.parents.get(parentTypeName);
-        if (parent) {
-            (0, utils_1.setLongestDescriptionForNode)(parent.node, node.description);
-            this.extractPersistedDirectives(node.directives || [], parent.directives);
-        }
-        switch (node.kind) {
-            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    parent.appearances += 1;
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    values: new Map(),
-                    kind: node.kind,
-                    node: (0, ast_1.enumTypeDefinitionNodeToMutable)(node),
-                });
-                return;
-            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    parent.appearances += 1;
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    fields: new Map(),
-                    kind: node.kind,
-                    node: (0, ast_1.inputObjectTypeDefinitionNodeToMutable)(node),
-                });
-                return;
-            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    (0, utils_1.extractInterfaces)(node, parent.interfaces);
-                    parent.subgraphNames.add(this.currentSubgraphName);
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    fields: new Map(),
-                    interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
-                    kind: node.kind,
-                    node: (0, ast_1.interfaceTypeDefinitionNodeToMutable)(node),
-                    subgraphNames: new Set([this.currentSubgraphName]),
-                });
-                return;
-            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    kind: node.kind,
-                    node: (0, ast_1.scalarTypeDefinitionNodeToMutable)(node),
-                });
-                return;
-            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    (0, utils_1.extractInterfaces)(node, parent.interfaces);
-                    parent.subgraphNames.add(this.currentSubgraphName);
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    fields: new Map(),
-                    interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
-                    isRootType: this.isParentRootType,
-                    kind: node.kind,
-                    node: (0, ast_1.objectTypeDefinitionNodeToMutable)(node),
-                    subgraphNames: new Set([this.currentSubgraphName]),
-                });
-                return;
-            case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                if (parent) {
-                    if (parent.kind !== node.kind) {
-                        throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
-                    }
-                    if (!node.types || node.types.length < 1) {
-                        this.errors.push((0, errors_1.invalidUnionError)(parent.node.name.value));
-                        return;
-                    }
-                    node.types?.forEach((member) => parent.members.add(member.name.value));
-                    return;
-                }
-                this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-                    kind: node.kind,
-                    members: new Set(node.types?.map((member) => member.name.value)),
-                    node: (0, ast_1.unionTypeDefinitionNodeToMutable)(node),
-                });
-                return;
-        }
-    }
-    upsertExtensionNode(node) {
-        const extension = this.extensions.get(this.parentTypeName);
-        if (extension) {
-            if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.OBJECT_TYPE_EXTENSION, extension.kind);
-            }
-            extension.subgraphNames.add(this.currentSubgraphName);
-            (0, utils_1.extractInterfaces)(node, extension.interfaces);
-            this.extractPersistedDirectives(node.directives || [], extension.directives);
-            return;
-        }
-        // build a new extension
-        const interfaces = (0, utils_1.extractInterfaces)(node, new Set());
-        this.extensions.set(this.parentTypeName, {
-            directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
-            fields: new Map(),
-            interfaces,
-            isRootType: this.isParentRootType,
-            kind: graphql_1.Kind.OBJECT_TYPE_EXTENSION,
-            node: (0, ast_1.objectTypeExtensionNodeToMutable)(node),
-            subgraphNames: new Set([this.currentSubgraphName]),
-        });
-    }
-    isTypeValidImplementation(originalType, implementationType) {
-        if (originalType.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            if (implementationType.kind !== graphql_1.Kind.NON_NULL_TYPE) {
-                return false;
-            }
-            return this.isTypeValidImplementation(originalType.type, implementationType.type);
-        }
-        if (implementationType.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            return this.isTypeValidImplementation(originalType, implementationType.type);
-        }
-        switch (originalType.kind) {
-            case graphql_1.Kind.NAMED_TYPE:
-                if (implementationType.kind === graphql_1.Kind.NAMED_TYPE) {
-                    const originalTypeName = originalType.name.value;
-                    const implementationTypeName = implementationType.name.value;
-                    if (originalTypeName === implementationTypeName) {
-                        return true;
-                    }
-                    const concreteTypes = this.abstractToConcreteTypeNames.get(originalTypeName);
-                    if (!concreteTypes) {
-                        return false;
-                    }
-                    return concreteTypes.has(implementationTypeName);
-                }
-                return false;
-            default:
-                if (implementationType.kind === graphql_1.Kind.LIST_TYPE) {
-                    return this.isTypeValidImplementation(originalType.type, implementationType.type);
-                }
-                return false;
-        }
-    }
-    getAndValidateImplementedInterfaces(container) {
+    getValidImplementedInterfaces(data) {
         const interfaces = [];
-        if (container.interfaces.size < 1) {
+        if (data.implementedInterfaceTypeNames.size < 1) {
             return interfaces;
         }
         const implementationErrorsMap = new Map();
-        for (const interfaceName of container.interfaces) {
+        for (const interfaceName of data.implementedInterfaceTypeNames) {
             interfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceName));
-            const interfaceContainer = this.parents.get(interfaceName);
-            if (!interfaceContainer) {
+            const interfaceData = this.parentDefinitionDataByTypeName.get(interfaceName);
+            if (!interfaceData) {
                 this.errors.push((0, errors_1.undefinedTypeError)(interfaceName));
                 continue;
             }
-            if (interfaceContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
-                throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceContainer.kind);
+            if (interfaceData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceData.kind);
             }
             const implementationErrors = {
                 invalidFieldImplementations: new Map(),
                 unimplementedFields: [],
             };
             let hasErrors = false;
-            for (const [fieldName, interfaceField] of interfaceContainer.fields) {
+            for (const [fieldName, interfaceField] of interfaceData.fieldDataByFieldName) {
                 let hasNestedErrors = false;
-                const containerField = container.fields.get(fieldName);
-                if (!containerField) {
+                const fieldData = data.fieldDataByFieldName.get(fieldName);
+                if (!fieldData) {
                     hasErrors = true;
                     implementationErrors.unimplementedFields.push(fieldName);
                     continue;
@@ -645,25 +99,25 @@ class FederationFactory {
                     unimplementedArguments: new Set(),
                 };
                 // The implemented field type must be equally or more restrictive than the original interface field type
-                if (!this.isTypeValidImplementation(interfaceField.node.type, containerField.node.type)) {
+                if (!(0, utils_4.isTypeValidImplementation)(interfaceField.node.type, fieldData.node.type, this.concreteTypeNamesByAbstractTypeName)) {
                     hasErrors = true;
                     hasNestedErrors = true;
-                    invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
+                    invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(fieldData.node.type);
                 }
                 const handledArguments = new Set();
-                for (const [argumentName, inputValueContainer] of interfaceField.arguments) {
-                    const interfaceArgument = inputValueContainer.node;
+                for (const [argumentName, inputValueData] of interfaceField.argumentDataByArgumentName) {
+                    const interfaceArgument = inputValueData.node;
                     handledArguments.add(argumentName);
-                    const containerArgument = containerField.arguments.get(argumentName)?.node;
+                    const argumentNode = fieldData.argumentDataByArgumentName.get(argumentName)?.node;
                     // The type implementing the interface must include all arguments with no variation for that argument
-                    if (!containerArgument) {
+                    if (!argumentNode) {
                         hasErrors = true;
                         hasNestedErrors = true;
                         invalidFieldImplementation.unimplementedArguments.add(argumentName);
                         continue;
                     }
                     // Implemented arguments should be the exact same type
-                    const actualType = (0, merge_1.printTypeNode)(containerArgument.type);
+                    const actualType = (0, merge_1.printTypeNode)(argumentNode.type);
                     const expectedType = (0, merge_1.printTypeNode)(interfaceArgument.type);
                     if (expectedType !== actualType) {
                         hasErrors = true;
@@ -672,7 +126,7 @@ class FederationFactory {
                     }
                 }
                 // Additional arguments must be optional (nullable)
-                for (const [argumentName, inputValueContainer] of containerField.arguments) {
+                for (const [argumentName, inputValueContainer] of fieldData.argumentDataByArgumentName) {
                     const argumentNode = inputValueContainer.node;
                     if (handledArguments.has(argumentName)) {
                         continue;
@@ -693,168 +147,10 @@ class FederationFactory {
             }
         }
         if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.node.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(data.node.name.value, (0, utils_2.kindToTypeString)(data.kind), implementationErrorsMap));
         }
         return interfaces;
     }
-    mergeArguments(container, args, errors, argumentNames) {
-        for (const argumentContainer of container.arguments.values()) {
-            const missingSubgraphs = (0, utils_3.getEntriesNotInHashSet)(container.subgraphNames, argumentContainer.subgraphs);
-            const argumentName = argumentContainer.node.name.value;
-            if (missingSubgraphs.length > 0) {
-                // Required arguments must be defined in all subgraphs that define the field
-                if (argumentContainer.requiredSubgraphs.size > 0) {
-                    errors.push({
-                        argumentName,
-                        missingSubgraphs,
-                        requiredSubgraphs: [...argumentContainer.requiredSubgraphs],
-                    });
-                }
-                // If the argument is always optional, but it's not defined in all subgraphs that define the field,
-                // the argument should not be included in the federated graph
-                continue;
-            }
-            argumentContainer.node.defaultValue = argumentContainer.includeDefaultValue
-                ? argumentContainer.node.defaultValue
-                : undefined;
-            args.push((0, utils_1.pushPersistedDirectivesAndGetNode)(argumentContainer));
-            if (argumentNames) {
-                argumentNames.push(argumentName);
-            }
-        }
-    }
-    addValidExecutableDirectiveDefinition(directiveName, directiveContainer, definitions) {
-        if (!this.executableDirectives.has(directiveName)) {
-            return;
-        }
-        if (this.internalSubgraphBySubgraphName.size !== directiveContainer.subgraphNames.size) {
-            return;
-        }
-        directiveContainer.node.locations = (0, utils_1.setToNameNodeArray)(directiveContainer.executableLocations);
-        if (!directiveContainer.arguments) {
-            definitions.push(directiveContainer.node);
-            return;
-        }
-        const args = [];
-        const errors = [];
-        this.mergeArguments(directiveContainer, args, errors);
-        if (errors.length > 0) {
-            this.errors.push((0, errors_1.invalidRequiredArgumentsError)(string_constants_1.DIRECTIVE_DEFINITION, directiveName, errors));
-            return;
-        }
-        directiveContainer.node.arguments = args;
-        definitions.push(directiveContainer.node);
-    }
-    pushAuthorizationDirectives(fieldContainer, parentTypeName) {
-        const authorizationData = this.authorizationDataByParentTypeName.get(parentTypeName);
-        if (!authorizationData) {
-            return;
-        }
-        const fieldAuthorizationData = authorizationData.fieldAuthorizationDataByFieldName.get(fieldContainer.node.name.value);
-        if (!fieldAuthorizationData) {
-            return;
-        }
-        if (fieldAuthorizationData.requiresAuthentication) {
-            fieldContainer.directives.directives.set(string_constants_1.AUTHENTICATED, [(0, utils_3.generateSimpleDirective)(string_constants_1.AUTHENTICATED)]);
-        }
-        if (fieldAuthorizationData.requiredScopes.length > 0) {
-            fieldContainer.directives.directives.set(string_constants_1.REQUIRES_SCOPES, [
-                (0, utils_3.generateRequiresScopesDirective)(fieldAuthorizationData.requiredScopes),
-            ]);
-        }
-    }
-    getMergedFieldDefinitionNode(fieldContainer, parentTypeName) {
-        this.pushAuthorizationDirectives(fieldContainer, parentTypeName);
-        (0, utils_1.pushPersistedDirectivesAndGetNode)(fieldContainer);
-        if (fieldContainer.arguments.size < 1) {
-            return fieldContainer.node;
-        }
-        const fieldName = fieldContainer.node.name.value;
-        const fieldPath = `${parentTypeName}.${fieldName}`;
-        const args = [];
-        const errors = [];
-        const argumentNames = [];
-        this.mergeArguments(fieldContainer, args, errors, argumentNames);
-        if (errors.length > 0) {
-            this.errors.push((0, errors_1.invalidRequiredArgumentsError)(string_constants_1.FIELD, fieldPath, errors));
-        }
-        else if (argumentNames.length > 0) {
-            this.fieldConfigurationByFieldPath.set(`${parentTypeName}.${fieldName}`, {
-                argumentNames,
-                fieldName,
-                typeName: parentTypeName,
-            });
-        }
-        fieldContainer.node.arguments = args;
-        return fieldContainer.node;
-    }
-    // the deprecated directive with the longest reason is kept
-    upsertDeprecatedDirective(directive, deprecatedDirectiveContainer) {
-        if (!directive.arguments || directive.arguments.length < 1) {
-            deprecatedDirectiveContainer.directive = directive;
-            return;
-        }
-        if (directive.arguments.length !== 1) {
-            this.errors.push(errors_1.invalidDeprecatedDirectiveError);
-            return;
-        }
-        const reasonArgument = directive.arguments[0].value;
-        if (reasonArgument.kind !== graphql_1.Kind.STRING) {
-            this.errors.push(errors_1.invalidDeprecatedDirectiveError);
-            return;
-        }
-        if (deprecatedDirectiveContainer.reason &&
-            reasonArgument.value.length < deprecatedDirectiveContainer.reason.length) {
-            return;
-        }
-        deprecatedDirectiveContainer.reason = reasonArgument.value;
-        deprecatedDirectiveContainer.directive = directive;
-    }
-    // tags with the same name string are merged
-    mergeTagDirectives(directive, map) {
-        // the directive has been validated in the normalizer
-        if (!directive.arguments || directive.arguments.length !== 1) {
-            this.errors.push(errors_1.invalidTagDirectiveError); // should never happen
-            return;
-        }
-        const nameArgument = directive.arguments[0].value;
-        if (nameArgument.kind !== graphql_1.Kind.STRING) {
-            this.errors.push(errors_1.invalidTagDirectiveError); // should never happen
-            return;
-        }
-        map.set(nameArgument.value, directive);
-    }
-    extractPersistedDirectives(directives, container) {
-        if (directives.length < 1) {
-            return container;
-        }
-        for (const directive of directives) {
-            const directiveName = directive.name.value;
-            if (!this.persistedDirectives.has(directiveName)) {
-                continue;
-            }
-            if (directiveName == string_constants_1.DEPRECATED) {
-                this.upsertDeprecatedDirective(directive, container.deprecated);
-                continue;
-            }
-            if (directiveName === string_constants_1.TAG) {
-                this.mergeTagDirectives(directive, container.tags);
-                continue;
-            }
-            const existingDirectives = container.directives.get(directiveName);
-            if (!existingDirectives) {
-                container.directives.set(directiveName, [directive]);
-                continue;
-            }
-            // Naïvely ignore non-repeatable directives
-            const definition = (0, utils_3.getOrThrowError)(this.directiveDefinitions, directiveName, 'directiveDefinitions');
-            if (!definition.node.repeatable) {
-                continue;
-            }
-            existingDirectives.push(directive);
-        }
-        return container;
-    }
     isFieldResolvableByEntityAncestor(entityAncestors, fieldSubgraphs, parentTypeName) {
         if (!this.graph.hasNode(parentTypeName)) {
             return false;
@@ -865,11 +161,11 @@ class FederationFactory {
                 return true;
             }
             if (entityAncestorName === parentTypeName) {
-                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityContainersByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
+                const hasOverlap = (0, utils_2.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_2.getOrThrowError)(this.entityContainersByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
                 this.graphPaths.set(path, hasOverlap);
                 return hasOverlap;
             }
-            if ((0, utils_3.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
+            if ((0, utils_2.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
                 this.graphPaths.set(path, true);
                 return true;
             }
@@ -887,22 +183,8 @@ class FederationFactory {
         }
         return false;
     }
-    isFieldExternalInAllMutualSubgraphs(subgraphs, fieldContainer) {
-        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(subgraphs, fieldContainer.subgraphNames);
-        if (mutualSubgraphs.size < 1) {
-            return false;
-        }
-        for (const mutualSubgraph of mutualSubgraphs) {
-            const isExternal = fieldContainer.subgraphsByExternal.get(mutualSubgraph);
-            if (isExternal) {
-                continue;
-            }
-            return false;
-        }
-        return true;
-    }
     updateEvaluatedSubgraphOccurrences(rootTypeFieldSubgraphs, objectSubgraphs, entityAncestors, parentTypeName) {
-        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, objectSubgraphs);
+        const mutualSubgraphs = (0, utils_2.getAllMutualEntries)(rootTypeFieldSubgraphs, objectSubgraphs);
         if (mutualSubgraphs.size > 0) {
             for (const mutualSubgraph of mutualSubgraphs) {
                 const evaluatedObjects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
@@ -914,23 +196,23 @@ class FederationFactory {
                 }
             }
         }
-        for (const entityAncestor of entityAncestors) {
-            const entityContainer = (0, utils_3.getOrThrowError)(this.parents, entityAncestor, string_constants_1.PARENTS);
-            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, entityContainer.subgraphNames);
-            const mutualEntityAncestorSubgraphs = (0, utils_3.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
-            for (const mutualSubgraph of mutualEntityAncestorSubgraphs) {
-                const objects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
+        for (const entityAncestorTypeName of entityAncestors) {
+            const entityContainer = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, entityAncestorTypeName, 'parentDefinitionDataByTypeName');
+            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_2.getAllMutualEntries)(rootTypeFieldSubgraphs, entityContainer.subgraphNames);
+            const mutualEntityAncestorSubgraphsNames = (0, utils_2.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
+            for (const mutualSubgraphName of mutualEntityAncestorSubgraphsNames) {
+                const objects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraphName);
                 if (objects) {
                     objects.add(parentTypeName);
                 }
                 else {
-                    this.evaluatedObjectLikesBySubgraph.set(mutualSubgraph, new Set([parentTypeName]));
+                    this.evaluatedObjectLikesBySubgraph.set(mutualSubgraphName, new Set([parentTypeName]));
                 }
             }
         }
     }
-    evaluateResolvabilityOfObject(parentContainer, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, isParentAbstract = false) {
-        const parentTypeName = parentContainer.node.name.value;
+    evaluateResolvabilityOfObject(objectData, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, isParentAbstract = false) {
+        const parentTypeName = objectData.name;
         if (evaluatedObjectLikes.has(parentTypeName)) {
             return;
         }
@@ -938,68 +220,68 @@ class FederationFactory {
             evaluatedObjectLikes.add(parentTypeName);
             return;
         }
-        for (const [fieldName, fieldContainer] of parentContainer.fields) {
-            const fieldNamedTypeName = fieldContainer.namedTypeName;
-            if (string_constants_1.ROOT_TYPES.has(fieldNamedTypeName)) {
+        for (const [fieldName, fieldData] of objectData.fieldDataByFieldName) {
+            const namedFieldTypeName = fieldData.namedTypeName;
+            if (string_constants_1.ROOT_TYPES.has(namedFieldTypeName)) {
                 continue;
             }
             // Avoid an infinite loop with self-referential objects
-            if (evaluatedObjectLikes.has(fieldNamedTypeName)) {
+            if (evaluatedObjectLikes.has(namedFieldTypeName)) {
                 continue;
             }
-            if (this.isFieldExternalInAllMutualSubgraphs(rootTypeFieldData.subgraphs, fieldContainer)) {
+            if ((0, utils_4.isFieldExternalInAllMutualSubgraphs)(rootTypeFieldData.subgraphs, fieldData)) {
                 continue;
             }
-            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, parentContainer.subgraphNames, entityAncestors, parentTypeName);
+            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, objectData.subgraphNames, entityAncestors, parentTypeName);
             evaluatedObjectLikes.add(parentTypeName);
-            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphNames) ||
-                this.isFieldResolvableByEntityAncestor(entityAncestors, fieldContainer.subgraphNames, parentTypeName);
+            const isFieldResolvable = (0, utils_2.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
+                this.isFieldResolvableByEntityAncestor(entityAncestors, fieldData.subgraphNames, parentTypeName);
             const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
-            const entity = this.entityContainersByTypeName.get(fieldNamedTypeName);
+            const entity = this.entityContainersByTypeName.get(namedFieldTypeName);
             if (isFieldResolvable) {
                 // The base scalars are not in this.parentMap
-                if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
+                if (constants_1.BASE_SCALARS.has(namedFieldTypeName)) {
                     continue;
                 }
-                const childContainer = (0, utils_3.getOrThrowError)(this.parents, fieldNamedTypeName, string_constants_1.PARENTS);
-                switch (childContainer.kind) {
+                const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
+                switch (namedTypeData.kind) {
                     case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                         continue;
                     case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
+                        this.evaluateResolvabilityOfObject(namedTypeData, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, namedFieldTypeName] : [...entityAncestors]);
                         continue;
                     case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
+                        this.evaluateResolvabilityOfAbstractType(namedFieldTypeName, namedTypeData.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, namedFieldTypeName] : [...entityAncestors]);
                         continue;
                     default:
-                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
                         continue;
                 }
             }
-            if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
-                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphNames], newCurrentFieldPath, parentTypeName));
+            if (constants_1.BASE_SCALARS.has(namedFieldTypeName)) {
+                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath, parentTypeName));
                 continue;
             }
-            const childContainer = (0, utils_3.getOrThrowError)(this.parents, fieldNamedTypeName, string_constants_1.PARENTS);
-            switch (childContainer.kind) {
+            const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
+            switch (namedTypeData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphNames], newCurrentFieldPath, parentTypeName));
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath, parentTypeName));
                     continue;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphNames], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
                     continue;
                 default:
-                    this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+                    this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
             }
         }
     }
@@ -1008,30 +290,30 @@ class FederationFactory {
             return;
         }
         evaluatedObjectLikes.add(abstractTypeName);
-        const concreteTypeNames = this.abstractToConcreteTypeNames.get(abstractTypeName);
+        const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
         if (!concreteTypeNames) {
-            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(abstractKind), abstractTypeName);
+            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_2.kindToTypeString)(abstractKind), abstractTypeName);
             return;
         }
         for (const concreteTypeName of concreteTypeNames) {
             if (evaluatedObjectLikes.has(concreteTypeName)) {
                 continue;
             }
-            const concreteParentContainer = (0, utils_3.getOrThrowError)(this.parents, concreteTypeName, string_constants_1.PARENTS);
-            if (concreteParentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_3.kindToTypeString)(concreteParentContainer.kind));
+            const concreteTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, 'parentDefinitionDataByTypeName');
+            if (concreteTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_2.kindToTypeString)(concreteTypeData.kind));
             }
             // If the concrete type is unreachable through an inline fragment, it is not an error
-            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteParentContainer.subgraphNames, rootTypeFieldData.subgraphs)) {
+            if (!(0, utils_2.doSetsHaveAnyOverlap)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
                 continue;
             }
             const entity = this.entityContainersByTypeName.get(concreteTypeName);
-            this.evaluateResolvabilityOfObject(concreteParentContainer, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, evaluatedObjectLikes, entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
+            this.evaluateResolvabilityOfObject(concreteTypeData, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, evaluatedObjectLikes, entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
         }
     }
     validateKeyFieldSetsForImplicitEntity(entityContainer) {
-        const internalSubgraph = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
-        const parentContainerByTypeName = internalSubgraph.parentDataByTypeName;
+        const internalSubgraph = (0, utils_2.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
+        const parentContainerByTypeName = internalSubgraph.parentDefinitionDataByTypeName;
         const extensionContainerByTypeName = internalSubgraph.parentExtensionDataByTypeName;
         const implicitEntityContainer = parentContainerByTypeName.get(entityContainer.typeName) ||
             extensionContainerByTypeName.get(entityContainer.typeName);
@@ -1040,7 +322,7 @@ class FederationFactory {
                 implicitEntityContainer.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION)) {
             throw (0, errors_1.incompatibleParentKindFatalError)(entityContainer.typeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, implicitEntityContainer?.kind || graphql_1.Kind.NULL);
         }
-        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataMap, entityContainer.typeName, 'internalSubgraph.configurationDataMap');
+        const configurationData = (0, utils_2.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityContainer.typeName, 'internalSubgraph.configurationDataMap');
         const keyFieldNames = new Set();
         const keys = [];
         // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
@@ -1068,19 +350,15 @@ class FederationFactory {
                 Field: {
                     enter(node) {
                         const parentContainer = parentContainers[currentDepth];
-                        const parentTypeName = parentContainer.typeName;
                         // If an object-like was just visited, a selection set should have been entered
                         if (shouldDefineSelectionSet) {
                             shouldAddKeyFieldSet = false;
                             return graphql_1.BREAK;
                         }
                         const fieldName = node.name.value;
-                        const fieldPath = `${parentTypeName}.${fieldName}`;
-                        const fieldContainer = parentContainer.fieldDataByFieldName.get(fieldName);
+                        const fieldData = parentContainer.fieldDataByFieldName.get(fieldName);
                         // undefined if the field does not exist on the parent
-                        if (!fieldContainer ||
-                            fieldContainer.argumentDataByArgumentName.size ||
-                            definedFields[currentDepth].has(fieldName)) {
+                        if (!fieldData || fieldData.argumentDataByArgumentName.size || definedFields[currentDepth].has(fieldName)) {
                             shouldAddKeyFieldSet = false;
                             return graphql_1.BREAK;
                         }
@@ -1090,7 +368,7 @@ class FederationFactory {
                         if (currentDepth === 0) {
                             keyFieldNames.add(fieldName);
                         }
-                        const namedTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.node.type);
+                        const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
                         // The base scalars are not in the parents map
                         if (constants_1.BASE_SCALARS.has(namedTypeName)) {
                             return;
@@ -1150,10 +428,10 @@ class FederationFactory {
                 continue;
             }
             // Add any top-level fields that compose the key in case they are external
-            (0, utils_3.addIterableValuesToSet)(keyFieldNames, configurationData.fieldNames);
+            (0, utils_2.addIterableValuesToSet)(keyFieldNames, configurationData.fieldNames);
             keys.push({
                 fieldName: '',
-                selectionSet: (0, utils_4.getNormalizedFieldSet)(documentNode),
+                selectionSet: (0, utils_3.getNormalizedFieldSet)(documentNode),
                 disableEntityResolver: true,
             });
         }
@@ -1162,51 +440,76 @@ class FederationFactory {
             configurationData.keys = keys;
         }
     }
-    handleAuthorizationDataForRenamedTypes() {
-        for (const [originalTypeName, renamedTypeName] of this.renamedTypeNameByOriginalTypeName) {
-            const originalAuthorizationData = this.authorizationDataByParentTypeName.get(originalTypeName);
-            if (!originalAuthorizationData) {
+    getEnumValueMergeMethod(enumTypeName) {
+        if (this.namedInputValueTypeNames.has(enumTypeName)) {
+            if (this.namedOutputTypeNames.has(enumTypeName)) {
+                return utils_4.MergeMethod.CONSISTENT;
+            }
+            return utils_4.MergeMethod.INTERSECTION;
+        }
+        return utils_4.MergeMethod.UNION;
+    }
+    federate() {
+        const persistedDirectiveDefinitionDataByDirectiveName = new Map();
+        let shouldSkipPersistedExecutableDirectives = false;
+        let subgraphNumber = 0;
+        let isVersionTwo = false;
+        for (const internalSubgraph of this.internalSubgraphBySubgraphName.values()) {
+            subgraphNumber += 1;
+            this.currentSubgraphName = internalSubgraph.name;
+            isVersionTwo ||= internalSubgraph.isVersionTwo;
+            (0, walkers_1.createMultiGraphAndRenameRootTypes)(this, internalSubgraph);
+            for (const parentDefinitionData of internalSubgraph.parentDefinitionDataByTypeName.values()) {
+                (0, utils_4.upsertParentDefinitionData)(this.parentDefinitionDataByTypeName, parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.entityInterfaceFederationDataByTypeName, this.namedOutputTypeNames, this.namedInputValueTypeNames, internalSubgraph.name, this.errors);
+            }
+            for (const objectExtensionData of internalSubgraph.parentExtensionDataByTypeName.values()) {
+                (0, utils_4.upsertObjectExtensionData)(this.objectExtensionDataByTypeName, objectExtensionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedOutputTypeNames, this.namedInputValueTypeNames, this.errors);
+            }
+            if (shouldSkipPersistedExecutableDirectives) {
                 continue;
             }
-            originalAuthorizationData.typeName = renamedTypeName;
-            const renamedAuthorizationData = this.authorizationDataByParentTypeName.get(renamedTypeName);
-            if (!renamedAuthorizationData) {
-                this.authorizationDataByParentTypeName.set(renamedTypeName, originalAuthorizationData);
+            /* If a subgraph defines no executable directives, it is not possible for any definition to be in all subgraphs.
+               Consequently, it is no longer necessary to check for any persisted executable directives. */
+            if (!internalSubgraph.persistedDirectiveDefinitionDataByDirectiveName.size) {
+                shouldSkipPersistedExecutableDirectives = true;
+                continue;
             }
-            else {
-                for (const [fieldName, incomingFieldAuthorizationData,] of renamedAuthorizationData.fieldAuthorizationDataByFieldName) {
-                    if (!(0, utils_3.upsertFieldAuthorizationData)(originalAuthorizationData.fieldAuthorizationDataByFieldName, incomingFieldAuthorizationData)) {
-                        this.invalidOrScopesHostPaths.add(`${renamedTypeName}.${fieldName}`);
-                    }
-                }
+            for (const persistedDirectiveDefinitionData of internalSubgraph.persistedDirectiveDefinitionDataByDirectiveName.values()) {
+                (0, utils_4.upsertPersistedDirectiveDefinitionData)(persistedDirectiveDefinitionDataByDirectiveName, persistedDirectiveDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedInputValueTypeNames, subgraphNumber, this.errors);
+            }
+            /* Invalid directives keys are deleted; if there are no entries left, it is no longer necessary to evaluate more
+               executable directives. */
+            if (!persistedDirectiveDefinitionDataByDirectiveName.size) {
+                shouldSkipPersistedExecutableDirectives = true;
             }
-            this.authorizationDataByParentTypeName.delete(originalTypeName);
         }
-    }
-    federate() {
-        this.populateMultiGraphAndRenameOperations(this.internalSubgraphBySubgraphName);
-        const factory = this;
-        for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
-            this.isCurrentSubgraphVersionTwo = subgraph.isVersionTwo;
-            this.currentSubgraphName = subgraph.name;
-            this.keyFieldNamesByParentTypeName = subgraph.keyFieldNamesByParentTypeName;
-            (0, subgraph_1.walkSubgraphToFederate)(subgraph.definitions, subgraph.overriddenFieldNamesByParentTypeName, factory);
+        const definitions = isVersionTwo
+            ? [
+                constants_1.AUTHENTICATED_DEFINITION,
+                constants_1.DEPRECATED_DEFINITION,
+                constants_1.INACCESSIBLE_DEFINITION,
+                constants_1.REQUIRES_SCOPES_DEFINITION,
+                constants_1.TAG_DEFINITION,
+                constants_1.SCOPE_SCALAR_DEFINITION,
+            ]
+            : [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
+        for (const data of persistedDirectiveDefinitionDataByDirectiveName.values()) {
+            (0, utils_4.addValidPersistedDirectiveDefinitionNodeByData)(definitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
         }
-        this.handleAuthorizationDataForRenamedTypes();
         for (const [typeName, entityInterfaceData] of this.entityInterfaceFederationDataByTypeName) {
-            (0, utils_3.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
-            const entityInterface = (0, utils_3.getOrThrowError)(this.parents, typeName, 'parents');
+            (0, utils_2.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
+            const entityInterface = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, 'parentDefinitionDataByTypeName');
             if (entityInterface.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 // TODO error
                 continue;
             }
             for (const subgraphName of entityInterfaceData.interfaceObjectSubgraphs) {
-                const configurationDataMap = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataMap;
-                const concreteTypeNames = this.abstractToConcreteTypeNames.get(typeName);
+                const configurationDataMap = (0, utils_2.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataByParentTypeName;
+                const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(typeName);
                 if (!concreteTypeNames) {
                     continue;
                 }
-                const interfaceObjectConfiguration = (0, utils_3.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
+                const interfaceObjectConfiguration = (0, utils_2.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
                 const keys = interfaceObjectConfiguration.keys;
                 if (!keys) {
                     // TODO no keys error
@@ -1221,15 +524,15 @@ class FederationFactory {
                         continue;
                     }
                     if (authorizationData) {
-                        const concreteAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_3.newAuthorizationData)(concreteTypeName));
+                        const concreteAuthorizationData = (0, utils_2.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_2.newAuthorizationData)(concreteTypeName));
                         for (const fieldAuthorizationData of authorizationData.fieldAuthorizationDataByFieldName.values()) {
-                            if (!(0, utils_3.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, fieldAuthorizationData)) {
+                            if (!(0, utils_2.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, fieldAuthorizationData)) {
                                 this.invalidOrScopesHostPaths.add(`${concreteTypeName}.${fieldAuthorizationData.fieldName}`);
                             }
                         }
                     }
-                    const concreteTypeContainer = (0, utils_3.getOrThrowError)(this.parents, concreteTypeName, 'parents');
-                    if (concreteTypeContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                    const concreteTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, 'parentDefinitionDataByTypeName');
+                    if (concreteTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                         continue;
                     }
                     // The subgraph locations of the interface object must be added to the concrete types that implement it
@@ -1245,198 +548,284 @@ class FederationFactory {
                         typeName: concreteTypeName,
                     };
                     for (const fieldName of entityInterfaceData.interfaceObjectFieldNames) {
-                        const existingFieldContainer = concreteTypeContainer.fields.get(fieldName);
-                        if (existingFieldContainer) {
+                        const existingFieldData = concreteTypeData.fieldDataByFieldName.get(fieldName);
+                        if (existingFieldData) {
                             // TODO handle shareability
                             continue;
                         }
-                        const interfaceFieldContainer = (0, utils_3.getOrThrowError)(entityInterface.fields, fieldName, 'entityInterface.fields');
-                        concreteTypeContainer.fields.set(fieldName, { ...interfaceFieldContainer });
+                        const interfaceFieldData = (0, utils_2.getOrThrowError)(entityInterface.fieldDataByFieldName, fieldName, `${typeName}.fieldDataByFieldName`);
+                        concreteTypeData.fieldDataByFieldName.set(fieldName, { ...interfaceFieldData });
                     }
                     configurationDataMap.set(concreteTypeName, configurationData);
                 }
             }
         }
         if (this.invalidOrScopesHostPaths.size > 0) {
-            this.errors.push((0, errors_1.orScopesLimitError)(utils_3.maxOrScopes, [...this.invalidOrScopesHostPaths]));
-        }
-        const definitions = [];
-        for (const [directiveName, directiveContainer] of this.directiveDefinitions) {
-            if (this.persistedDirectiveDefinitions.has(directiveName)) {
-                definitions.push(directiveContainer.node);
-                continue;
-            }
-            // The definitions must be present in all subgraphs to be kept in the federated graph
-            this.addValidExecutableDirectiveDefinition(directiveName, directiveContainer, definitions);
-        }
-        if (this.directiveDefinitions.has(string_constants_1.REQUIRES_SCOPES)) {
-            definitions.push(constants_1.SCOPE_SCALAR_DEFINITION);
-        }
-        for (const [typeName, extension] of this.extensions) {
-            this.parentTypeName = typeName;
-            if (extension.isRootType && !this.parents.has(typeName)) {
-                this.upsertParentNode((0, ast_1.objectTypeExtensionNodeToMutableDefinitionNode)(extension.node));
-            }
-            const baseObject = this.parents.get(typeName);
-            if (!baseObject) {
-                this.errors.push((0, errors_1.noBaseTypeExtensionError)(typeName));
-                continue;
-            }
-            if (baseObject.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                throw (0, errors_1.incompatibleParentKindFatalError)(typeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, baseObject.kind);
-            }
-            this.upsertExtensionPersistedDirectives(extension.directives, baseObject.directives);
-            for (const [extensionFieldName, extensionFieldContainer] of extension.fields) {
-                const baseFieldContainer = baseObject.fields.get(extensionFieldName);
-                if (!baseFieldContainer) {
-                    baseObject.fields.set(extensionFieldName, extensionFieldContainer);
-                    continue;
-                }
-                if (baseFieldContainer.isShareable && extensionFieldContainer.isShareable) {
-                    this.childName = extensionFieldName;
-                    this.upsertExtensionFieldArguments(extensionFieldContainer.arguments, baseFieldContainer.arguments);
-                    (0, utils_1.setLongestDescriptionForNode)(baseFieldContainer.node, extensionFieldContainer.node.description);
-                    (0, utils_3.addIterableValuesToSet)(extensionFieldContainer.subgraphNames, baseFieldContainer.subgraphNames);
-                    continue;
-                }
-                const parent = this.shareableErrorTypeNames.get(typeName);
-                if (parent) {
-                    parent.add(extensionFieldName);
-                    continue;
-                }
-                this.shareableErrorTypeNames.set(typeName, new Set([extensionFieldName]));
-            }
-            for (const interfaceName of extension.interfaces) {
-                baseObject.interfaces.add(interfaceName);
-            }
-        }
-        for (const [parentTypeName, children] of this.shareableErrorTypeNames) {
-            const parent = (0, utils_3.getOrThrowError)(this.parents, parentTypeName, string_constants_1.PARENTS);
-            if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, parent.kind);
-            }
-            this.errors.push((0, errors_1.shareableFieldDefinitionsError)(parent, children));
-        }
-        const objectLikeContainersWithInterfaces = [];
-        for (const [parentTypeName, parentContainer] of this.parents) {
-            switch (parentContainer.kind) {
+            this.errors.push((0, errors_1.orScopesLimitError)(utils_2.maxOrScopes, [...this.invalidOrScopesHostPaths]));
+        }
+        for (const [parentTypeName, objectExtensionData] of this.objectExtensionDataByTypeName) {
+            (0, utils_4.upsertValidObjectExtensionData)(this.parentDefinitionDataByTypeName, objectExtensionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedOutputTypeNames, this.namedInputValueTypeNames, this.errors, this.authorizationDataByParentTypeName.get(parentTypeName));
+        }
+        // for (const [typeName, extension] of this.extensions) {
+        //   this.parentTypeName = typeName;
+        //   if (extension.isRootType && !this.parents.has(typeName)) {
+        //     this.upsertParentNode(objectTypeExtensionNodeToMutableDefinitionNode(extension.node));
+        //   }
+        //   const baseObject = this.parents.get(typeName);
+        //   if (!baseObject) {
+        //     this.errors.push(noBaseTypeExtensionError(typeName));
+        //     continue;
+        //   }
+        //
+        //   if (baseObject.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+        //     throw incompatibleParentKindFatalError(typeName, Kind.OBJECT_TYPE_DEFINITION, baseObject.kind);
+        //   }
+        //   this.upsertExtensionPersistedDirectives(extension.directives, baseObject.directives);
+        //   for (const [extensionFieldName, extensionFieldContainer] of extension.fields) {
+        //     const baseFieldContainer = baseObject.fields.get(extensionFieldName);
+        //     if (!baseFieldContainer) {
+        //       baseObject.fields.set(extensionFieldName, extensionFieldContainer);
+        //       continue;
+        //     }
+        //     if (baseFieldContainer.isShareable && extensionFieldContainer.isShareable) {
+        //       this.childName = extensionFieldName;
+        //       this.upsertExtensionFieldArguments(extensionFieldContainer.arguments, baseFieldContainer.arguments);
+        //       addIterableValuesToSet(extensionFieldContainer.subgraphNames, baseFieldContainer.subgraphNames);
+        //       continue;
+        //     }
+        //     const parent = this.shareableErrorTypeNames.get(typeName);
+        //     if (parent) {
+        //       parent.add(extensionFieldName);
+        //       continue;
+        //     }
+        //     this.shareableErrorTypeNames.set(typeName, new Set<string>([extensionFieldName]));
+        //   }
+        //   for (const interfaceName of extension.interfaces) {
+        //     baseObject.interfaces.add(interfaceName);
+        //   }
+        // }
+        // for (const [parentTypeName, children] of this.shareableErrorTypeNames) {
+        //   const parent = getOrThrowError(this.parents, parentTypeName, PARENTS);
+        //   if (parent.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+        //     throw incompatibleParentKindFatalError(parentTypeName, Kind.OBJECT_TYPE_DEFINITION, parent.kind);
+        //   }
+        //   this.errors.push(shareableFieldDefinitionsError(parent, children));
+        // }
+        const definitionsWithInterfaces = [];
+        for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
+            switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    const values = [];
-                    const mergeMethod = this.getEnumMergeMethod(parentTypeName);
-                    for (const enumValueContainer of parentContainer.values.values()) {
-                        (0, utils_1.pushPersistedDirectivesAndGetNode)(enumValueContainer);
+                    const enumValueNodes = [];
+                    const mergeMethod = this.getEnumValueMergeMethod(parentTypeName);
+                    for (const enumValueData of parentDefinitionData.enumValueDataByValueName.values()) {
+                        const enumValueNode = (0, utils_4.getNodeWithPersistedDirectivesByData)(enumValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
                         switch (mergeMethod) {
-                            case utils_2.MergeMethod.CONSISTENT:
-                                if (enumValueContainer.appearances < parentContainer.appearances) {
+                            case utils_4.MergeMethod.CONSISTENT:
+                                if (parentDefinitionData.appearances > enumValueData.appearances) {
                                     this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentTypeName));
                                 }
-                                values.push(enumValueContainer.node);
+                                enumValueNodes.push(enumValueNode);
                                 break;
-                            case utils_2.MergeMethod.INTERSECTION:
-                                if (enumValueContainer.appearances === parentContainer.appearances) {
-                                    values.push(enumValueContainer.node);
+                            case utils_4.MergeMethod.INTERSECTION:
+                                if (parentDefinitionData.appearances === enumValueData.appearances) {
+                                    enumValueNodes.push(enumValueNode);
                                 }
                                 break;
                             default:
-                                values.push(enumValueContainer.node);
+                                enumValueNodes.push(enumValueNode);
                                 break;
                         }
                     }
-                    parentContainer.node.values = values;
-                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
+                    parentDefinitionData.node.values = enumValueNodes;
+                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    const inputValues = [];
-                    for (const inputValueContainer of parentContainer.fields.values()) {
-                        (0, utils_1.pushPersistedDirectivesAndGetNode)(inputValueContainer);
-                        if (parentContainer.appearances === inputValueContainer.appearances) {
-                            inputValues.push(inputValueContainer.node);
+                    const invalidRequiredInputs = [];
+                    const inputValueNodes = [];
+                    for (const [inputValueName, inputValueData] of parentDefinitionData.inputValueDataByValueName) {
+                        if (parentDefinitionData.subgraphNames.size === inputValueData.subgraphNames.size) {
+                            inputValueNodes.push((0, utils_4.getNodeWithPersistedDirectivesByInputValueData)(inputValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                         }
-                        else if ((0, type_merging_1.isTypeRequired)(inputValueContainer.node.type)) {
-                            this.errors.push((0, errors_1.federationRequiredInputFieldError)(parentTypeName, inputValueContainer.node.name.value));
-                            break;
+                        else if ((0, utils_4.isTypeRequired)(inputValueData.type)) {
+                            invalidRequiredInputs.push({
+                                inputValueName,
+                                missingSubgraphs: (0, utils_2.getEntriesNotInHashSet)(parentDefinitionData.subgraphNames, inputValueData.subgraphNames),
+                                requiredSubgraphs: [...inputValueData.requiredSubgraphNames],
+                            });
                         }
                     }
-                    parentContainer.node.fields = inputValues;
-                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
-                    break;
-                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                    const interfaceFields = [];
-                    for (const fieldContainer of parentContainer.fields.values()) {
-                        if ((0, utils_2.isFieldInaccessible)(fieldContainer)) {
-                            continue;
-                        }
-                        interfaceFields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
-                    }
-                    parentContainer.node.fields = interfaceFields;
-                    (0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer);
-                    // Interface implementations can only be evaluated after they've been fully merged
-                    if (parentContainer.interfaces.size > 0) {
-                        objectLikeContainersWithInterfaces.push(parentContainer);
-                    }
-                    else {
-                        definitions.push(parentContainer.node);
-                    }
-                    if (interfaceFields.length < 1) {
-                        this.errors.push((0, errors_1.allFieldDefinitionsAreInaccessibleError)('interface', parentTypeName));
+                    if (invalidRequiredInputs.length > 0) {
+                        this.errors.push((0, errors_1.invalidRequiredInputValueError)(string_constants_1.INPUT_OBJECT, parentTypeName, invalidRequiredInputs, false));
+                        break;
                     }
+                    parentDefinitionData.node.fields = inputValueNodes;
+                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const fields = [];
-                    for (const fieldContainer of parentContainer.fields.values()) {
-                        if ((0, utils_2.isFieldInaccessible)(fieldContainer)) {
+                    const fieldNodes = [];
+                    const invalidFieldNames = new Set();
+                    const isObject = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION;
+                    for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByFieldName) {
+                        (0, utils_4.pushAuthorizationDirectives)(fieldData, this.authorizationDataByParentTypeName.get(parentTypeName));
+                        const argumentNodes = (0, utils_4.getValidFieldArgumentNodes)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, this.fieldConfigurationByFieldPath, this.errors);
+                        if (isObject && !(0, utils_4.isShareabilityOfAllFieldInstancesValid)(fieldData)) {
+                            invalidFieldNames.add(fieldName);
+                        }
+                        if (fieldData.isInaccessible) {
                             continue;
                         }
-                        fields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
+                        fieldNodes.push((0, utils_4.getNodeWithPersistedDirectivesByFieldData)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, argumentNodes, this.errors));
                     }
-                    parentContainer.node.fields = fields;
-                    (0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer);
-                    // Interface implementations can only be evaluated after they've been fully merged
-                    if (parentContainer.interfaces.size > 0) {
-                        objectLikeContainersWithInterfaces.push(parentContainer);
+                    if (isObject && invalidFieldNames.size > 0) {
+                        this.errors.push((0, errors_1.invalidFieldShareabilityError)(parentDefinitionData, invalidFieldNames));
+                    }
+                    parentDefinitionData.node.fields = fieldNodes;
+                    // Implemented interfaces can only be validated after all fields are merged
+                    if (parentDefinitionData.implementedInterfaceTypeNames.size > 0) {
+                        definitionsWithInterfaces.push(parentDefinitionData);
                     }
                     else {
-                        definitions.push(parentContainer.node);
+                        definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     }
-                    if (fields.length < 1) {
-                        if ((0, utils_4.isNodeQuery)(parentTypeName)) {
+                    if (fieldNodes.length < 1) {
+                        if ((0, utils_3.isNodeQuery)(parentTypeName)) {
                             this.errors.push(errors_1.noQueryRootTypeError);
                         }
                         else {
-                            this.errors.push((0, errors_1.allFieldDefinitionsAreInaccessibleError)('object', parentTypeName));
+                            this.errors.push((0, errors_1.allFieldDefinitionsAreInaccessibleError)((0, utils_2.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
                         }
                     }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     if (!constants_1.BASE_SCALARS.has(parentTypeName)) {
-                        definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
+                        definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     }
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    const types = [];
-                    for (const memberName of parentContainer.members) {
-                        types.push((0, utils_1.stringToNamedTypeNode)(memberName));
-                    }
-                    parentContainer.node.types = types;
-                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
+                    parentDefinitionData.node.types = (0, utils_2.mapToArrayOfValues)(parentDefinitionData.memberByMemberTypeName);
+                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     break;
             }
         }
-        for (const container of objectLikeContainersWithInterfaces) {
-            container.node.interfaces = this.getAndValidateImplementedInterfaces(container);
-            definitions.push(container.node);
-        }
-        const query = this.parents.get(string_constants_1.QUERY);
-        if (!query || query.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION || query.fields.size < 1) {
+        // for (const [parentTypeName, parentContainer] of this.parents) {
+        //   switch (parentContainer.kind) {
+        // case Kind.ENUM_TYPE_DEFINITION:
+        //   const values: MutableEnumValueDefinitionNode[] = [];
+        //   const mergeMethod = this.getEnumMergeMethod(parentTypeName);
+        //   for (const enumValueContainer of parentContainer.values.values()) {
+        //     pushPersistedDirectivesAndGetNode(enumValueContainer);
+        //     switch (mergeMethod) {
+        //       case MergeMethod.CONSISTENT:
+        //         if (enumValueContainer.appearances < parentContainer.appearances) {
+        //           this.errors.push(incompatibleSharedEnumError(parentTypeName));
+        //         }
+        //         values.push(enumValueContainer.node);
+        //         break;
+        //       case MergeMethod.INTERSECTION:
+        //         if (enumValueContainer.appearances === parentContainer.appearances) {
+        //           values.push(enumValueContainer.node);
+        //         }
+        //         break;
+        //       default:
+        //         values.push(enumValueContainer.node);
+        //         break;
+        //     }
+        //   }
+        //   parentContainer.node.values = values;
+        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
+        //   break;
+        // case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+        //   const inputValues: InputValueDefinitionNode[] = [];
+        //   for (const inputValueContainer of parentContainer.fields.values()) {
+        //     pushPersistedDirectivesAndGetNode(inputValueContainer);
+        //     if (parentContainer.appearances === inputValueContainer.appearances) {
+        //       inputValues.push(inputValueContainer.node);
+        //     } else if (isTypeRequired(inputValueContainer.node.type)) {
+        //       this.errors.push(federationRequiredInputFieldError(parentTypeName, inputValueContainer.node.name.value));
+        //       break;
+        //     }
+        //   }
+        //   parentContainer.node.fields = inputValues;
+        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
+        //   break;
+        // case Kind.INTERFACE_TYPE_DEFINITION:
+        //   const interfaceFields: FieldDefinitionNode[] = [];
+        //   for (const fieldContainer of parentContainer.fields.values()) {
+        //     if (isFieldInaccessible(fieldContainer)) {
+        //       continue;
+        //     }
+        //     interfaceFields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
+        //   }
+        //   parentContainer.node.fields = interfaceFields;
+        //   pushPersistedDirectivesAndGetNode(parentContainer);
+        //   // Interface implementations can only be evaluated after they've been fully merged
+        //   if (parentContainer.interfaces.size > 0) {
+        //     definitionsWithInterfaces.push(parentContainer);
+        //   } else {
+        //     definitions.push(parentContainer.node);
+        //   }
+        //   if (interfaceFields.length < 1) {
+        //     this.errors.push(allFieldDefinitionsAreInaccessibleError('interface', parentTypeName));
+        //   }
+        //   break;
+        // case Kind.OBJECT_TYPE_DEFINITION:
+        //   const fields: FieldDefinitionNode[] = [];
+        //   for (const fieldContainer of parentContainer.fields.values()) {
+        //     if (isFieldInaccessible(fieldContainer)) {
+        //       continue;
+        //     }
+        //     fields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
+        //   }
+        //   parentContainer.node.fields = fields;
+        //   pushPersistedDirectivesAndGetNode(parentContainer);
+        //   // Interface implementations can only be evaluated after they've been fully merged
+        //   if (parentContainer.interfaces.size > 0) {
+        //     definitionsWithInterfaces.push(parentContainer);
+        //   }
+        // } else {
+        //   definitions.push(parentContainer.node);
+        // }
+        // if (fields.length < 1) {
+        //   if (isNodeQuery(parentTypeName)) {
+        //     this.errors.push(noQueryRootTypeError);
+        //   } else {
+        //     this.errors.push(allFieldDefinitionsAreInaccessibleError('object', parentTypeName));
+        //   }
+        // }
+        // break;
+        // case Kind.SCALAR_TYPE_DEFINITION:
+        //   if (!BASE_SCALARS.has(parentTypeName)) {
+        //     definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
+        //   }
+        //   break;
+        // case Kind.UNION_TYPE_DEFINITION:
+        //   const types: NamedTypeNode[] = [];
+        //   for (const memberName of parentContainer.members) {
+        //     types.push(stringToNamedTypeNode(memberName));
+        //   }
+        //   parentContainer.node.types = types;
+        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
+        //   break;
+        //   }
+        // }
+        for (const data of definitionsWithInterfaces) {
+            data.node.interfaces = this.getValidImplementedInterfaces(data);
+            definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(data, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+        }
+        const query = this.parentDefinitionDataByTypeName.get(string_constants_1.QUERY);
+        if (!query || query.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION || query.fieldDataByFieldName.size < 1) {
             this.errors.push(errors_1.noQueryRootTypeError);
         }
         // return any composition errors before checking whether all fields are resolvable
         if (this.errors.length > 0) {
             return { errors: this.errors };
         }
+        // TODO add back resolvability check
         for (const rootTypeName of string_constants_1.ROOT_TYPES) {
-            const rootTypeContainer = this.parents.get(rootTypeName);
-            if (!rootTypeContainer || rootTypeContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            const rootTypeData = this.parentDefinitionDataByTypeName.get(rootTypeName);
+            if (!rootTypeData || rootTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                 continue;
             }
             // After evaluating all of a root type's fields, break and return if there are errors
@@ -1445,41 +834,41 @@ class FederationFactory {
             }
             // If a root type field returns a Scalar or Enum, track it so that it is not evaluated it again
             const evaluatedRootScalarsAndEnums = new Set(constants_1.BASE_SCALARS);
-            for (const [rootTypeFieldName, rootTypeFieldContainer] of rootTypeContainer.fields) {
-                const rootTypeFieldNamedTypeName = rootTypeFieldContainer.namedTypeName;
-                if (evaluatedRootScalarsAndEnums.has(rootTypeFieldNamedTypeName)) {
+            for (const [rootTypeFieldName, fieldData] of rootTypeData.fieldDataByFieldName) {
+                const namedRootFieldTypeName = fieldData.namedTypeName;
+                if (evaluatedRootScalarsAndEnums.has(namedRootFieldTypeName)) {
                     continue;
                 }
-                if (!this.shouldEvaluateObjectLike(rootTypeFieldContainer.subgraphNames, rootTypeFieldNamedTypeName)) {
+                if (!this.shouldEvaluateObjectLike(fieldData.subgraphNames, namedRootFieldTypeName)) {
                     continue;
                 }
-                const childContainer = (0, utils_3.getOrThrowError)(this.parents, rootTypeFieldNamedTypeName, string_constants_1.PARENTS);
+                const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedRootFieldTypeName, 'parentDefinitionDataByTypeName');
                 const fieldPath = `${rootTypeName}.${rootTypeFieldName}`;
                 const rootTypeFieldData = {
                     fieldName: rootTypeFieldName,
-                    fieldTypeNodeString: (0, merge_1.printTypeNode)(rootTypeFieldContainer.node.type),
+                    fieldTypeNodeString: (0, merge_1.printTypeNode)(fieldData.node.type),
                     path: fieldPath,
                     typeName: rootTypeName,
-                    subgraphs: rootTypeFieldContainer.subgraphNames,
+                    subgraphs: fieldData.subgraphNames,
                 };
-                switch (childContainer.kind) {
+                switch (namedTypeData.kind) {
                     case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                         // Root type fields whose response type is an Enums and Scalars will always be resolvable
                         // Consequently, subsequent checks can be skipped
-                        evaluatedRootScalarsAndEnums.add(rootTypeFieldNamedTypeName);
+                        evaluatedRootScalarsAndEnums.add(namedRootFieldTypeName);
                         continue;
                     case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
+                        this.evaluateResolvabilityOfObject(namedTypeData, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
                         continue;
                     case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(rootTypeFieldNamedTypeName, childContainer.kind, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
+                        this.evaluateResolvabilityOfAbstractType(namedRootFieldTypeName, namedTypeData.kind, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
                         continue;
                     default:
-                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
                 }
             }
         }
@@ -1494,12 +883,12 @@ class FederationFactory {
         const subgraphConfigBySubgraphName = new Map();
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphConfigBySubgraphName.set(subgraph.name, {
-                configurationDataMap: subgraph.configurationDataMap,
+                configurationDataMap: subgraph.configurationDataByParentTypeName,
                 schema: subgraph.schema,
             });
         }
         for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
-            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+            (0, utils_2.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
         }
         return {
             federationResult: {
@@ -1517,7 +906,7 @@ function federateSubgraphs(subgraphs) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError] };
     }
-    const { authorizationDataByParentTypeName, entityContainerByTypeName, errors, internalSubgraphBySubgraphName, warnings, } = (0, normalization_factory_1.batchNormalize)(subgraphs);
+    const { authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainerByTypeName, errors, graph, internalSubgraphBySubgraphName, warnings, } = (0, normalization_factory_1.batchNormalize)(subgraphs);
     if (errors) {
         return { errors };
     }
@@ -1528,7 +917,7 @@ function federateSubgraphs(subgraphs) {
         for (const [typeName, entityInterfaceData] of internalSubgraph.entityInterfaces) {
             // Always add each entity interface to the invalid entity interfaces map
             // If not, earlier checks would not account for implementations not yet seen
-            const invalidEntityInterfaces = (0, utils_3.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []);
+            const invalidEntityInterfaces = (0, utils_2.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []);
             invalidEntityInterfaces.push({
                 subgraphName,
                 concreteTypeNames: entityInterfaceData.concreteTypeNames || new Set(),
@@ -1536,10 +925,10 @@ function federateSubgraphs(subgraphs) {
             const existingData = entityInterfaceFederationDataByTypeName.get(typeName);
             if (!existingData) {
                 validEntityInterfaceTypeNames.add(typeName);
-                entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_3.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
+                entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_2.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
                 continue;
             }
-            const areAnyImplementationsUndefined = (0, utils_3.upsertEntityInterfaceFederationData)(existingData, entityInterfaceData, subgraphName);
+            const areAnyImplementationsUndefined = (0, utils_2.upsertEntityInterfaceFederationData)(existingData, entityInterfaceData, subgraphName);
             if (areAnyImplementationsUndefined) {
                 validEntityInterfaceTypeNames.delete(typeName);
             }
@@ -1556,7 +945,7 @@ function federateSubgraphs(subgraphs) {
             ],
         };
     }
-    return new FederationFactory(authorizationDataByParentTypeName, entityContainerByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings).federate();
+    return new FederationFactory(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainerByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings).federate();
 }
 exports.federateSubgraphs = federateSubgraphs;
 //# sourceMappingURL=federation-factory.js.map