@wundergraph/composition 0.17.1 → 0.18.1

package/dist/normalization/normalization-factory.js

@@ -5,7 +5,7 @@ const graphql_1 = require("graphql");
 const utils_1 = require("../ast/utils");
 const utils_2 = require("./utils");
 const constants_1 = require("../utils/constants");
-const type_merging_1 = require("../type-merging/type-merging");
+const type_merging_1 = require("../schema-building/type-merging");
 const utils_3 = require("../utils/utils");
 const errors_1 = require("../errors/errors");
 const string_constants_1 = require("../utils/string-constants");
@@ -14,6 +14,8 @@ const merge_1 = require("@graphql-tools/merge");
 const ast_1 = require("../ast/ast");
 const subgraph_1 = require("../subgraph/subgraph");
 const warnings_1 = require("../warnings/warnings");
+const walkers_1 = require("./walkers");
+const utils_4 = require("../schema-building/utils");
 function normalizeSubgraphFromString(subgraphSDL) {
     const { error, documentNode } = (0, utils_1.safeParse)(subgraphSDL);
     if (error || !documentNode) {
@@ -30,7 +32,7 @@ function normalizeSubgraph(document, subgraphName) {
 exports.normalizeSubgraph = normalizeSubgraph;
 class NormalizationFactory {
     abstractToConcreteTypeNames = new Map();
-    allDirectiveDefinitions = new Map();
+    directiveDefinitionByDirectiveName = new Map();
     argumentName = '';
     authorizationDataByParentTypeName = new Map();
     childName = '';
@@ -39,36 +41,38 @@ class NormalizationFactory {
     errors = [];
     entityContainerByTypeName = new Map();
     entityInterfaces = new Map();
-    extensionContainerByTypeName = new Map();
+    parentExtensionDataByTypeName = new Map();
+    interfaceTypeNamesWithAuthorizationDirectives = new Set();
     isCurrentParentExtension = false;
-    isCurrentParentRootType = false;
     isSubgraphVersionTwo = false;
     fieldSetContainerByTypeName = new Map();
+    heirFieldAuthorizationDataByTypeName = new Map();
     handledRepeatedDirectivesByHostPath = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
     lastChildNodeKind = graphql_1.Kind.NULL;
     leafTypeNamesWithAuthorizationDirectives = new Set();
     keyFieldNamesByParentTypeName = new Map();
     operationTypeNames = new Map();
-    parentContainerByTypeName = new Map();
+    parentDefinitionDataByTypeName = new Map();
     parentTypeName = '';
     parentsWithChildArguments = new Set();
     eventsConfigurations = new Map();
     overridesByTargetSubgraphName = new Map();
+    invalidOrScopesHostPaths = new Set();
     schemaDefinition;
-    referencedDirectives = new Set();
+    referencedDirectiveNames = new Set();
     referencedTypeNames = new Set();
     warnings = [];
     subgraphName;
     constructor(subgraphName) {
-        for (const baseDirectiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
-            this.allDirectiveDefinitions.set(baseDirectiveDefinition.name.value, baseDirectiveDefinition);
+        for (const [baseDirectiveName, baseDirectiveDefinition] of constants_1.BASE_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME) {
+            this.directiveDefinitionByDirectiveName.set(baseDirectiveName, baseDirectiveDefinition);
         }
         this.subgraphName = subgraphName;
         this.schemaDefinition = {
-            directives: new Map(),
+            directivesByDirectiveName: new Map(),
             kind: graphql_1.Kind.SCHEMA_DEFINITION,
-            name: (0, utils_1.stringToNameNode)(string_constants_1.SCHEMA),
+            typeName: string_constants_1.SCHEMA,
             operationTypes: new Map(),
         };
     }
@@ -76,7 +80,7 @@ class NormalizationFactory {
         if (constants_1.BASE_SCALARS.has(namedType)) {
             return { hasUnhandledError: false, typeString: '' };
         }
-        const parentContainer = this.parentContainerByTypeName.get(namedType);
+        const parentContainer = this.parentDefinitionDataByTypeName.get(namedType);
         if (!parentContainer) {
             this.errors.push((0, errors_1.undefinedTypeError)(namedType));
             return { hasUnhandledError: false, typeString: '' };
@@ -90,28 +94,28 @@ class NormalizationFactory {
                 return { hasUnhandledError: true, typeString: (0, utils_3.kindToTypeString)(parentContainer.kind) };
         }
     }
-    extractArguments(node, argumentByName, fieldPath) {
+    extractArguments(node, argumentDataByArgumentName, fieldPath) {
         if (!node.arguments) {
-            return argumentByName;
+            return argumentDataByArgumentName;
         }
         this.parentsWithChildArguments.add(this.parentTypeName);
         const duplicatedArguments = new Set();
         for (const argumentNode of node.arguments) {
             const argumentName = argumentNode.name.value;
-            if (argumentByName.has(argumentName)) {
+            if (argumentDataByArgumentName.has(argumentName)) {
                 duplicatedArguments.add(argumentName);
                 continue;
             }
-            argumentByName.set(argumentName, (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.parentTypeName));
+            argumentDataByArgumentName.set(argumentName, (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.parentTypeName));
         }
         if (duplicatedArguments.size > 0) {
             this.errors.push((0, errors_1.duplicateArgumentsError)(fieldPath, [...duplicatedArguments]));
         }
-        return argumentByName;
+        return argumentDataByArgumentName;
     }
-    validateArguments(fieldContainer, fieldPath) {
+    validateArguments(fieldData, fieldPath) {
         const invalidArguments = [];
-        for (const [argumentName, argumentNode] of fieldContainer.arguments) {
+        for (const [argumentName, argumentNode] of fieldData.argumentDataByArgumentName) {
             const namedType = (0, type_merging_1.getNamedTypeForChild)(fieldPath + `(${argumentName}...)`, argumentNode.type);
             const { hasUnhandledError, typeString } = this.validateInputNamedType(namedType);
             if (hasUnhandledError) {
@@ -122,51 +126,118 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.invalidArgumentsError)(fieldPath, invalidArguments));
         }
     }
-    extractDirectives(node, map) {
+    // Note that directive validation errors are handled elsewhere
+    getAuthorizationData(node) {
+        let authorizationData = this.authorizationDataByParentTypeName.get(this.parentTypeName);
+        (0, utils_3.resetAuthorizationData)(authorizationData);
         if (!node.directives) {
-            return map;
+            return authorizationData;
         }
-        for (const directive of node.directives) {
-            const directiveName = directive.name.value;
-            if (directiveName === string_constants_1.EXTENDS) {
+        let requiresAuthentication = false;
+        const requiresScopes = [];
+        for (const directiveNode of node.directives) {
+            const directiveName = directiveNode.name.value;
+            if (directiveName === string_constants_1.AUTHENTICATED) {
+                // @authenticated is not repeatable
+                if (requiresAuthentication) {
+                    return;
+                }
+                requiresAuthentication = true;
                 continue;
             }
-            const existingDirectives = map.get(directiveName);
-            if (existingDirectives) {
-                existingDirectives.push(directive);
+            if (directiveName !== string_constants_1.REQUIRES_SCOPES) {
                 continue;
             }
-            map.set(directiveName, [directive]);
+            // @requiresScopes is not repeatable
+            if (requiresScopes.length > 0) {
+                return;
+            }
+            requiresScopes.push(directiveNode);
         }
-        return map;
+        if (!requiresAuthentication && requiresScopes.length < 1) {
+            return authorizationData;
+        }
+        if ((0, utils_3.isNodeKindInterface)(node.kind)) {
+            this.interfaceTypeNamesWithAuthorizationDirectives.add(this.parentTypeName);
+        }
+        if (!authorizationData) {
+            authorizationData = (0, utils_3.setAndGetValue)(this.authorizationDataByParentTypeName, this.parentTypeName, (0, utils_3.newAuthorizationData)(this.parentTypeName));
+        }
+        authorizationData.hasParentLevelAuthorization = true;
+        authorizationData.requiresAuthentication = requiresAuthentication;
+        if (requiresScopes.length !== 1) {
+            return authorizationData;
+        }
+        const directiveNode = requiresScopes[0];
+        if (!directiveNode.arguments || directiveNode.arguments.length !== 1) {
+            return;
+        }
+        const scopesArgument = directiveNode.arguments[0];
+        if (scopesArgument.name.value !== string_constants_1.SCOPES || scopesArgument.value.kind !== graphql_1.Kind.LIST) {
+            return;
+        }
+        const orScopes = scopesArgument.value.values;
+        if (orScopes.length < 1) {
+            return authorizationData;
+        }
+        if (orScopes.length > utils_3.maxOrScopes) {
+            this.invalidOrScopesHostPaths.add(this.parentTypeName);
+            return;
+        }
+        for (const scopes of orScopes) {
+            if (scopes.kind !== graphql_1.Kind.LIST) {
+                return;
+            }
+            const andScopes = new Set();
+            for (const scope of scopes.values) {
+                if (scope.kind !== graphql_1.Kind.STRING) {
+                    return;
+                }
+                andScopes.add(scope.value);
+            }
+            if (andScopes.size) {
+                authorizationData.requiredScopes.push(andScopes);
+            }
+        }
+        return authorizationData;
     }
-    extractDirectivesAndAuthorization(node, map) {
+    extractDirectivesAndAuthorization(node, directivesByDirectiveName) {
         if (!node.directives) {
-            return map;
+            return directivesByDirectiveName;
         }
+        const hostPath = this.childName ? `${this.parentTypeName}.${this.childName}` : this.parentTypeName;
         const authorizationDirectives = [];
-        for (const directive of node.directives) {
-            const directiveName = directive.name.value;
+        for (const directiveNode of node.directives) {
+            const errorMessages = (0, utils_4.getDirectiveValidationErrors)(directiveNode, node.kind, directivesByDirectiveName, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, hostPath);
+            const directiveName = directiveNode.name.value;
+            if (errorMessages.length > 0) {
+                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
+                continue;
+            }
             if (directiveName === string_constants_1.EXTENDS) {
                 continue;
             }
+            if (directiveName === string_constants_1.OVERRIDE) {
+                this.handleOverrideDeclaration(directiveNode, hostPath, errorMessages);
+                if (errorMessages.length > 0) {
+                    this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
+                }
+                continue;
+            }
             if (directiveName === string_constants_1.AUTHENTICATED || directiveName === string_constants_1.REQUIRES_SCOPES) {
-                authorizationDirectives.push(directive);
+                authorizationDirectives.push(directiveNode);
+                continue;
             }
-            const existingDirectives = map.get(directiveName);
+            const existingDirectives = directivesByDirectiveName.get(directiveName);
             if (existingDirectives) {
-                existingDirectives.push(directive);
-                continue;
+                existingDirectives.push(directiveNode);
             }
-            map.set(directiveName, [directive]);
+            directivesByDirectiveName.set(directiveName, [directiveNode]);
         }
         if (authorizationDirectives.length < 1) {
-            return map;
+            return directivesByDirectiveName;
         }
-        if (node.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION ||
-            node.kind === graphql_1.Kind.ENUM_TYPE_EXTENSION ||
-            node.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
-            node.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
+        if (node.kind !== graphql_1.Kind.FIELD_DEFINITION) {
             this.leafTypeNamesWithAuthorizationDirectives.add(this.parentTypeName);
         }
         const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, this.parentTypeName, () => (0, utils_3.newAuthorizationData)(this.parentTypeName));
@@ -177,29 +248,14 @@ class NormalizationFactory {
                 authorizationData.requiresAuthentication = true;
                 continue;
             }
-            if (!directiveNode.arguments || directiveNode.arguments.length !== 1) {
-                break;
-            }
-            const scopesArgument = directiveNode.arguments[0];
-            if (scopesArgument.name.value !== string_constants_1.SCOPES) {
-                break;
-            }
-            if (scopesArgument.value.kind !== graphql_1.Kind.LIST) {
-                break;
-            }
-            const orScopes = scopesArgument.value.values;
-            if (orScopes.length < 1) {
+            const orScopes = directiveNode.arguments[0].value.values;
+            if (orScopes.length > utils_3.maxOrScopes) {
+                this.invalidOrScopesHostPaths.add(hostPath);
                 continue;
             }
             for (const scopes of orScopes) {
-                if (scopes.kind !== graphql_1.Kind.LIST) {
-                    return map;
-                }
                 const andScopes = new Set();
                 for (const scope of scopes.values) {
-                    if (scope.kind !== graphql_1.Kind.STRING) {
-                        return map;
-                    }
                     andScopes.add(scope.value);
                 }
                 if (andScopes.size) {
@@ -207,21 +263,7 @@ class NormalizationFactory {
                 }
             }
         }
-        return map;
-    }
-    extractUniqueUnionMembers(members, map) {
-        for (const member of members) {
-            const name = member.name.value;
-            if (map.has(name)) {
-                this.errors.push(new Error(`Member "${name} can only be defined on union "${this.parentTypeName}" once.`));
-                continue;
-            }
-            if (!constants_1.BASE_SCALARS.has(name)) {
-                this.referencedTypeNames.add(name);
-            }
-            map.set(name, member);
-        }
-        return map;
+        return directivesByDirectiveName;
     }
     mergeUniqueInterfaces(extensionInterfaces, interfaces, typeName) {
         for (const interfaceName of extensionInterfaces) {
@@ -232,109 +274,6 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.duplicateInterfaceExtensionError)(interfaceName, typeName));
         }
     }
-    mergeUniqueUnionMembers(baseUnion, extensionUnion) {
-        if (!extensionUnion) {
-            return;
-        }
-        const extensionMembers = extensionUnion.types;
-        const members = baseUnion.types;
-        const typeName = baseUnion.name.value;
-        for (const [memberName, namedTypeNode] of extensionMembers) {
-            if (!members.has(memberName)) {
-                members.set(memberName, namedTypeNode);
-                continue;
-            }
-            this.errors.push((0, errors_1.duplicateUnionMemberError)(memberName, typeName));
-        }
-    }
-    mergeDirectives(baseTypeDirectives, extension) {
-        if (!extension) {
-            return;
-        }
-        for (const [directiveName, directives] of extension.directives) {
-            const existingDirectives = baseTypeDirectives.get(directiveName);
-            if (existingDirectives) {
-                existingDirectives.push(...directives);
-                continue;
-            }
-            baseTypeDirectives.set(directiveName, [...directives]);
-        }
-    }
-    getValidatedAndNormalizedParentDirectives(parent) {
-        const parentTypeName = parent.name.value;
-        const normalizedDirectives = [];
-        for (const [directiveName, directives] of parent.directives) {
-            const definition = this.allDirectiveDefinitions.get(directiveName);
-            if (!definition) {
-                this.errors.push((0, errors_1.undefinedDirectiveError)(directiveName, parentTypeName));
-                continue;
-            }
-            const allArguments = new Set();
-            const requiredArguments = new Set();
-            (0, utils_2.getDirectiveDefinitionArgumentSets)(definition.arguments || [], allArguments, requiredArguments);
-            const entityKeys = new Set();
-            const errorMessages = [];
-            for (const directive of directives) {
-                if (!(0, utils_2.areNodeKindAndDirectiveLocationCompatible)(parent.kind, definition)) {
-                    errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(parentTypeName, parent.kind, directiveName));
-                }
-                if (!definition.repeatable && directives.length > 1) {
-                    errorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName, parentTypeName));
-                }
-                if (!definition.arguments || definition.arguments.length < 1) {
-                    if (directive.arguments && directive.arguments.length > 0) {
-                        errorMessages.push((0, errors_1.unexpectedDirectiveArgumentsErrorMessage)(directive, parentTypeName));
-                    }
-                    else {
-                        normalizedDirectives.push(directive);
-                    }
-                    continue;
-                }
-                if (!directive.arguments || directive.arguments.length < 1) {
-                    if (requiredArguments.size > 0) {
-                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, [...requiredArguments]));
-                    }
-                    else {
-                        normalizedDirectives.push(directive);
-                    }
-                    continue;
-                }
-                const definedArguments = (0, utils_2.getDefinedArgumentsForDirective)(directive.arguments, allArguments, directiveName, parentTypeName, errorMessages);
-                const missingRequiredArguments = (0, utils_3.getEntriesNotInHashSet)(requiredArguments, definedArguments);
-                if (missingRequiredArguments.length > 0) {
-                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, [...requiredArguments], missingRequiredArguments));
-                }
-                // Only add unique entity keys
-                if (directiveName === string_constants_1.KEY) {
-                    const directiveKind = directive.arguments[0].value.kind;
-                    if (directiveKind !== graphql_1.Kind.STRING) {
-                        errorMessages.push((0, errors_1.invalidKeyDirectiveArgumentErrorMessage)(directiveKind));
-                        continue;
-                    }
-                    const entityKey = directive.arguments[0].value.value;
-                    if (entityKeys.has(entityKey)) {
-                        continue;
-                    }
-                    entityKeys.add(entityKey);
-                }
-                normalizedDirectives.push(directive);
-            }
-            if (errorMessages.length > 0) {
-                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, parentTypeName, errorMessages));
-            }
-        }
-        return normalizedDirectives;
-    }
-    convertKindForExtension(node) {
-        switch (node.kind) {
-            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                return graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
-            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                return graphql_1.Kind.OBJECT_TYPE_EXTENSION;
-            default:
-                return node.kind;
-        }
-    }
     handleInterfaceObject(node) {
         if (!(0, utils_1.isNodeInterfaceObject)(node)) {
             return;
@@ -351,28 +290,22 @@ class NormalizationFactory {
             typeName: name,
         });
     }
-    handleObjectLikeExtension(node) {
+    handleExtensionWithFields(node) {
         this.isCurrentParentExtension = true;
-        const extension = this.extensionContainerByTypeName.get(this.parentTypeName);
-        const convertedKind = this.convertKindForExtension(node);
+        const extension = this.parentExtensionDataByTypeName.get(this.parentTypeName);
+        const convertedKind = (0, utils_4.convertKindForExtension)(node);
         if (extension) {
             if (extension.kind !== convertedKind) {
                 this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
                 return false;
             }
-            this.extractDirectivesAndAuthorization(node, extension.directives);
-            (0, utils_1.extractInterfaces)(node, extension.interfaces, this.errors);
+            (0, utils_4.extractDirectives)(node, extension.directivesByDirectiveName, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, this.parentTypeName);
+            (0, utils_1.extractInterfaces)(node, extension.implementedInterfaceTypeNames, this.errors);
             return;
         }
         const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-        this.extensionContainerByTypeName.set(this.parentTypeName, {
-            directives: this.extractDirectivesAndAuthorization(node, new Map()),
-            fields: new Map(),
-            interfaces: (0, utils_1.extractInterfaces)(node, new Set(), this.errors),
-            isEntity,
-            kind: convertedKind,
-            name: node.name,
-        });
+        (0, utils_4.upsertExtensionWithFieldsDataByNode)(this.parentExtensionDataByTypeName, node, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, isEntity);
+        // TODO re-assess this line
         if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION || !isEntity) {
             return;
         }
@@ -384,48 +317,6 @@ class NormalizationFactory {
             ...(this.subgraphName ? { subgraphNames: [this.subgraphName] } : {}),
         });
     }
-    validateChildDirectives(child, hostPath) {
-        const childKind = child.node.kind;
-        for (const [directiveName, directives] of child.directives) {
-            const definition = this.allDirectiveDefinitions.get(directiveName);
-            if (!definition) {
-                this.errors.push((0, errors_1.undefinedDirectiveError)(directiveName, hostPath));
-                continue;
-            }
-            const allArguments = new Set();
-            const requiredArguments = new Set();
-            (0, utils_2.getDirectiveDefinitionArgumentSets)(definition.arguments || [], allArguments, requiredArguments);
-            const errorMessages = [];
-            for (const directive of directives) {
-                if (!(0, utils_2.areNodeKindAndDirectiveLocationCompatible)(childKind, definition)) {
-                    errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(hostPath, childKind, directiveName));
-                }
-                if (!definition.repeatable && directives.length > 1) {
-                    errorMessages.push((0, errors_1.invalidRepeatedDirectiveErrorMessage)(directiveName, hostPath));
-                }
-                if (!definition.arguments || definition.arguments.length < 1) {
-                    if (directive.arguments && directive.arguments.length > 0) {
-                        errorMessages.push((0, errors_1.unexpectedDirectiveArgumentsErrorMessage)(directive, hostPath));
-                    }
-                    continue;
-                }
-                if (!directive.arguments || directive.arguments.length < 1) {
-                    if (requiredArguments.size > 0) {
-                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, [...requiredArguments]));
-                    }
-                    continue;
-                }
-                const definedArguments = (0, utils_2.getDefinedArgumentsForDirective)(directive.arguments, allArguments, directiveName, hostPath, errorMessages);
-                const missingRequiredArguments = (0, utils_3.getEntriesNotInHashSet)(requiredArguments, definedArguments);
-                if (missingRequiredArguments.length > 0) {
-                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, [...requiredArguments], missingRequiredArguments));
-                }
-            }
-            if (errorMessages.length > 0) {
-                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
-            }
-        }
-    }
     isTypeValidImplementation(originalType, implementationType) {
         if (originalType.kind === graphql_1.Kind.NON_NULL_TYPE) {
             if (implementationType.kind !== graphql_1.Kind.NON_NULL_TYPE) {
@@ -458,18 +349,6 @@ class NormalizationFactory {
                 return false;
         }
     }
-    canContainEventDirectives() {
-        if (!this.isCurrentParentRootType) {
-            return false;
-        }
-        const operationTypeNode = this.operationTypeNames.get(this.parentTypeName);
-        if (!operationTypeNode) {
-            return string_constants_1.ROOT_TYPES.has(this.parentTypeName);
-        }
-        return (operationTypeNode === graphql_1.OperationTypeNode.QUERY ||
-            operationTypeNode === graphql_1.OperationTypeNode.MUTATION ||
-            operationTypeNode === graphql_1.OperationTypeNode.SUBSCRIPTION);
-    }
     extractKeyFieldSets(node, fieldSetContainer) {
         const rawFieldSets = fieldSetContainer.keys;
         const parentTypeName = node.name.value;
@@ -511,12 +390,12 @@ class NormalizationFactory {
         }
     }
     validateInterfaceImplementations(container) {
-        if (container.interfaces.size < 1) {
+        if (container.implementedInterfaceTypeNames.size < 1) {
             return;
         }
         const implementationErrorsMap = new Map();
-        for (const interfaceName of container.interfaces) {
-            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parentContainerByTypeName, interfaceName, string_constants_1.PARENTS);
+        for (const interfaceName of container.implementedInterfaceTypeNames) {
+            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, interfaceName, string_constants_1.PARENTS);
             if (interfaceContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceContainer.kind);
             }
@@ -525,9 +404,9 @@ class NormalizationFactory {
                 unimplementedFields: [],
             };
             let hasErrors = false;
-            for (const [fieldName, interfaceField] of interfaceContainer.fields) {
+            for (const [fieldName, interfaceField] of interfaceContainer.fieldDataByFieldName) {
                 let hasNestedErrors = false;
-                const containerField = container.fields.get(fieldName);
+                const containerField = container.fieldDataByFieldName.get(fieldName);
                 if (!containerField) {
                     hasErrors = true;
                     implementationErrors.unimplementedFields.push(fieldName);
@@ -546,9 +425,9 @@ class NormalizationFactory {
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
                 }
                 const handledArguments = new Set();
-                for (const [argumentName, interfaceArgument] of interfaceField.arguments) {
+                for (const [argumentName, interfaceArgument] of interfaceField.argumentDataByArgumentName) {
                     handledArguments.add(argumentName);
-                    const containerArgument = containerField.arguments.get(argumentName);
+                    const containerArgument = containerField.argumentDataByArgumentName.get(argumentName);
                     // The type implementing the interface must include all arguments with no variation for that argument
                     if (!containerArgument) {
                         hasErrors = true;
@@ -566,11 +445,11 @@ class NormalizationFactory {
                     }
                 }
                 // Additional arguments must be optional (nullable)
-                for (const [argumentName, argumentNode] of containerField.arguments) {
+                for (const [argumentName, argumentData] of containerField.argumentDataByArgumentName) {
                     if (handledArguments.has(argumentName)) {
                         continue;
                     }
-                    if (argumentNode.type.kind !== graphql_1.Kind.NON_NULL_TYPE) {
+                    if (argumentData.type.kind !== graphql_1.Kind.NON_NULL_TYPE) {
                         continue;
                     }
                     hasErrors = true;
@@ -586,81 +465,25 @@ class NormalizationFactory {
             }
         }
         if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.typeName, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
         }
     }
-    handleOverride(node) {
-        if (node.name.value !== string_constants_1.OVERRIDE) {
+    handleOverrideDeclaration(node, hostPath, errorMessages) {
+        const argumentNode = node.arguments[0];
+        if (argumentNode.value.kind !== graphql_1.Kind.STRING) {
+            errorMessages.push((0, errors_1.invalidDirectiveArgumentTypeErrorMessage)(true, string_constants_1.FROM, graphql_1.Kind.STRING, argumentNode.value.kind));
             return;
         }
-        const errorMessages = [];
-        let hostPath = `${this.parentTypeName}.${this.childName}`;
-        let kind = this.lastChildNodeKind === graphql_1.Kind.NULL ? this.lastParentNodeKind : this.lastChildNodeKind;
-        if (this.argumentName) {
-            hostPath += `(${this.argumentName}: ...)`;
-            kind = graphql_1.Kind.ARGUMENT;
-        }
-        if (kind !== graphql_1.Kind.FIELD_DEFINITION) {
-            errorMessages.push((0, errors_1.invalidDirectiveLocationErrorMessage)(hostPath, kind, string_constants_1.OVERRIDE));
-        }
-        let targetSubgraphName = '';
-        if (node.arguments && node.arguments.length > 0) {
-            const observedArguments = new Set();
-            const handledDuplicateArguments = new Set();
-            for (const argumentNode of node.arguments) {
-                const argumentName = argumentNode.name.value;
-                if (argumentName !== string_constants_1.FROM && !observedArguments.has(argumentName)) {
-                    observedArguments.add(argumentName);
-                    errorMessages.push((0, errors_1.unexpectedDirectiveArgumentErrorMessage)(string_constants_1.OVERRIDE, argumentName));
-                    continue;
-                }
-                // If an argument is observed more than once, it is a duplication error.
-                // However, the error should only propagate once.
-                if (observedArguments.has(argumentName)) {
-                    if (!handledDuplicateArguments.has(argumentName)) {
-                        errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionErrorMessage)(string_constants_1.OVERRIDE, hostPath, argumentName));
-                    }
-                    continue;
-                }
-                if (argumentNode.value.kind !== graphql_1.Kind.STRING) {
-                    errorMessages.push((0, errors_1.invalidDirectiveArgumentTypeErrorMessage)(true, string_constants_1.FROM, graphql_1.Kind.STRING, argumentNode.value.kind));
-                }
-                else {
-                    observedArguments.add(string_constants_1.FROM);
-                    targetSubgraphName = argumentNode.value.value;
-                    if (targetSubgraphName === this.subgraphName) {
-                        this.errors.push((0, errors_1.equivalentSourceAndTargetOverrideError)(targetSubgraphName, hostPath));
-                    }
-                }
-            }
-            if (!observedArguments.has(string_constants_1.FROM)) {
-                errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.OVERRIDE, hostPath, [string_constants_1.FROM], [string_constants_1.FROM]));
-            }
-        }
-        else {
-            errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.OVERRIDE, hostPath, [string_constants_1.FROM], []));
-        }
-        if (errorMessages.length > 0) {
-            this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.OVERRIDE, hostPath, errorMessages));
+        const targetSubgraphName = argumentNode.value.value;
+        if (targetSubgraphName === this.subgraphName) {
+            errorMessages.push((0, errors_1.equivalentSourceAndTargetOverrideErrorMessage)(targetSubgraphName, hostPath));
             return;
         }
         const overrideDataForSubgraph = (0, utils_3.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
         const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.parentTypeName, () => new Set());
-        if (overriddenFieldNamesForParent.has(this.childName)) {
-            const handledRepeatedDirectives = this.handledRepeatedDirectivesByHostPath.get(hostPath);
-            // If the directive name exists as a value on the host path key, the repeatable error has been handled
-            if (handledRepeatedDirectives && handledRepeatedDirectives.has(string_constants_1.OVERRIDE)) {
-                return;
-            }
-            // Add the directive name to the existing set (if other invalid repeated directives exist) or a new set
-            (0, utils_3.getValueOrDefault)(this.handledRepeatedDirectivesByHostPath, hostPath, () => new Set()).add(string_constants_1.OVERRIDE);
-            // The invalid repeated directive error should propagate only once per directive per host path
-            this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.OVERRIDE, hostPath, [(0, errors_1.invalidRepeatedDirectiveErrorMessage)(string_constants_1.OVERRIDE, hostPath)]));
-            return;
-        }
         overriddenFieldNamesForParent.add(this.childName);
     }
-    extractEventDirectives(node) {
+    extractEventDirectivesToConfiguration(node) {
         if (!node.directives) {
             return;
         }
@@ -726,584 +549,52 @@ class NormalizationFactory {
         }
     }
     normalize(document) {
-        const factory = this;
         /* factory.allDirectiveDefinitions is initialized with v1 directive definitions, and v2 definitions are only added
         after the visitor has visited the entire schema and the subgraph is known to be a V2 graph. Consequently,
         allDirectiveDefinitions cannot be used to check for duplicate definitions, and another set (below) is required */
-        const definedDirectives = new Set();
-        const handledRootTypes = new Set();
         // Collect any renamed root types
-        (0, graphql_1.visit)(document, {
-            OperationTypeDefinition: {
-                enter(node) {
-                    const operationType = node.operation;
-                    const operationPath = `${factory.parentTypeName}.${operationType}`;
-                    const definitionNode = factory.schemaDefinition.operationTypes.get(operationType);
-                    const newTypeName = (0, type_merging_1.getNamedTypeForChild)(operationPath, node.type);
-                    if (definitionNode) {
-                        (0, errors_1.duplicateOperationTypeDefinitionError)(operationType, newTypeName, (0, type_merging_1.getNamedTypeForChild)(operationPath, definitionNode.type));
-                        return false;
-                    }
-                    const existingOperationType = factory.operationTypeNames.get(newTypeName);
-                    if (existingOperationType) {
-                        factory.errors.push((0, errors_1.invalidOperationTypeDefinitionError)(existingOperationType, newTypeName, operationType));
-                    }
-                    else {
-                        handledRootTypes.add(operationType);
-                        factory.operationTypeNames.set(newTypeName, operationType);
-                        factory.schemaDefinition.operationTypes.set(operationType, node);
-                    }
-                    return false;
-                },
-            },
-            SchemaDefinition: {
-                enter(node) {
-                    factory.extractDirectives(node, factory.schemaDefinition.directives);
-                    factory.schemaDefinition.description = node.description;
-                },
-            },
-            SchemaExtension: {
-                enter(node) {
-                    factory.extractDirectives(node, factory.schemaDefinition.directives);
-                },
-            },
-        });
-        (0, graphql_1.visit)(document, {
-            DirectiveDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (definedDirectives.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateDirectiveDefinitionError)(name));
-                        return false;
-                    }
-                    else {
-                        definedDirectives.add(name);
-                    }
-                    // Normalize federation directives by replacing them with predefined definitions
-                    if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
-                        factory.isSubgraphVersionTwo = true;
-                        return false;
-                    }
-                    // The V1 directives are always injected
-                    if (constants_1.VERSION_ONE_DIRECTIVES.has(name)) {
-                        return false;
-                    }
-                    factory.allDirectiveDefinitions.set(name, node);
-                    factory.customDirectiveDefinitions.set(name, node);
-                    return false;
-                },
-            },
-            Directive: {
-                enter(node) {
-                    const name = node.name.value;
-                    factory.handleOverride(node);
-                    if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
-                        factory.isSubgraphVersionTwo = true;
-                        return false;
-                    }
-                    if (constants_1.VERSION_ONE_DIRECTIVES.has(name)) {
-                        return false;
-                    }
-                    factory.referencedDirectives.add(name);
-                },
-            },
-            EnumTypeDefinition: {
-                enter(node) {
-                    const typeName = node.name.value;
-                    if (factory.parentContainerByTypeName.has(typeName)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), typeName));
-                        return false;
-                    }
-                    factory.parentTypeName = typeName;
-                    factory.lastParentNodeKind = node.kind;
-                    const directives = factory.extractDirectivesAndAuthorization(node, new Map());
-                    factory.parentContainerByTypeName.set(typeName, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives,
-                        kind: node.kind,
-                        name: node.name,
-                        values: new Map(),
-                    });
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            EnumTypeExtension: {
-                enter(node) {
-                    const name = node.name.value;
-                    factory.parentTypeName = name;
-                    factory.lastParentNodeKind = node.kind;
-                    factory.isCurrentParentExtension = true;
-                    const extension = factory.extensionContainerByTypeName.get(factory.parentTypeName);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectivesAndAuthorization(node, extension.directives);
-                        return;
-                    }
-                    factory.extensionContainerByTypeName.set(name, {
-                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                        kind: node.kind,
-                        name: node.name,
-                        values: new Map(),
-                    });
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                    factory.isCurrentParentExtension = false;
-                },
-            },
-            EnumValueDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    factory.childName = name;
-                    factory.lastChildNodeKind = node.kind;
-                    const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
-                    if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
-                        throw (0, errors_1.unexpectedKindFatalError)(name);
-                    }
-                    if (parent.values.has(name)) {
-                        const error = factory.isCurrentParentExtension
-                            ? (0, errors_1.duplicateValueExtensionError)('enum', factory.parentTypeName, name)
-                            : (0, errors_1.duplicateEnumValueDefinitionError)(name, factory.parentTypeName);
-                        factory.errors.push(error);
-                        return;
-                    }
-                    parent.values.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
-                        name,
-                        node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
-                    });
-                },
-                leave() {
-                    factory.childName = '';
-                    factory.lastChildNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            FieldDefinition: {
-                enter(node) {
-                    const fieldName = node.name.value;
-                    if (factory.isCurrentParentRootType && (fieldName === string_constants_1.SERVICE_FIELD || fieldName === string_constants_1.ENTITIES_FIELD)) {
-                        return false;
-                    }
-                    factory.childName = fieldName;
-                    factory.lastChildNodeKind = node.kind;
-                    if (factory.canContainEventDirectives()) {
-                        factory.extractEventDirectives(node);
-                    }
-                    const fieldPath = `${factory.parentTypeName}.${fieldName}`;
-                    factory.lastChildNodeKind = node.kind;
-                    const fieldNamedTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
-                    if (!constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
-                        factory.referencedTypeNames.add(fieldNamedTypeName);
-                    }
-                    const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
-                    if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
-                        parent.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
-                        parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
-                        parent.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
-                        throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
-                    }
-                    if (parent.fields.has(fieldName)) {
-                        factory.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, factory.parentTypeName));
-                        return;
-                    }
-                    // recreate the node so the argument descriptions are updated
-                    const fieldContainer = {
-                        arguments: factory.extractArguments(node, new Map(), fieldPath),
-                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                        name: fieldName,
-                        node: {
-                            ...node,
-                            arguments: node.arguments?.map((arg) => ({
-                                ...arg,
-                                description: (0, utils_1.formatDescription)(arg.description),
-                            })),
-                        },
-                    };
-                    parent.fields.set(fieldName, fieldContainer);
-                    const entityContainer = factory.entityContainerByTypeName.get(factory.parentTypeName);
-                    if (entityContainer) {
-                        entityContainer.fieldNames.add(fieldName);
-                        // Only entities will have an existing FieldSet
-                        const existingFieldSet = factory.fieldSetContainerByTypeName.get(factory.parentTypeName);
-                        if (existingFieldSet) {
-                            // @requires should only be defined on a field whose parent is an entity
-                            // If there is existingFieldSet, it's an entity
-                            (0, utils_2.extractFieldSetValue)(fieldName, existingFieldSet.requires, fieldContainer.directives.get(string_constants_1.REQUIRES));
-                            // @provides only makes sense on entities, but the field can be encountered before the type definition
-                            // When the FieldSet is evaluated, it will be checked whether the field is an entity.
-                            (0, utils_2.extractFieldSetValue)(fieldName, existingFieldSet.provides, fieldContainer.directives.get(string_constants_1.PROVIDES));
-                            return;
-                        }
-                    }
-                    const providesDirectives = fieldContainer.directives.get(string_constants_1.PROVIDES);
-                    // Check whether the directive exists to avoid creating unnecessary fieldSet configurations
-                    if (!providesDirectives) {
-                        return;
-                    }
-                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, factory.parentTypeName, utils_2.newFieldSetContainer);
-                    // @provides only makes sense on entities, but the field can be encountered before the type definition
-                    // When the FieldSet is evaluated, it will be checked whether the field is an entity.
-                    (0, utils_2.extractFieldSetValue)(fieldName, fieldSetContainer.provides, providesDirectives);
-                },
-                leave() {
-                    factory.childName = '';
-                    factory.lastChildNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            InputObjectTypeDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (factory.parentContainerByTypeName.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
-                        return false;
-                    }
-                    factory.lastParentNodeKind = node.kind;
-                    factory.parentTypeName = name;
-                    factory.parentContainerByTypeName.set(name, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
-                        fields: new Map(),
-                        kind: node.kind,
-                        name: node.name,
-                    });
-                },
-                leave() {
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                    factory.parentTypeName = '';
-                },
-            },
-            InputObjectTypeExtension: {
-                enter(node) {
-                    const name = node.name.value;
-                    factory.parentTypeName = name;
-                    factory.lastParentNodeKind = node.kind;
-                    factory.isCurrentParentExtension = true;
-                    const extension = factory.extensionContainerByTypeName.get(factory.parentTypeName);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectives(node, extension.directives);
-                        return;
-                    }
-                    factory.extensionContainerByTypeName.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
-                        fields: new Map(),
-                        kind: node.kind,
-                        name: node.name,
-                    });
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                    factory.isCurrentParentExtension = false;
-                },
-            },
-            InputValueDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    // If the parent is not an object type definition/extension, this node is an argument
-                    if (factory.lastParentNodeKind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION &&
-                        factory.lastParentNodeKind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
-                        factory.argumentName = name;
-                        return;
-                    }
-                    factory.childName = name;
-                    factory.lastChildNodeKind = node.kind;
-                    const valueRootTypeName = (0, type_merging_1.getNamedTypeForChild)(`${factory.parentTypeName}.${name}`, node.type);
-                    if (!constants_1.BASE_SCALARS.has(valueRootTypeName)) {
-                        factory.referencedTypeNames.add(valueRootTypeName);
-                    }
-                    const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
-                    if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
-                        throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
-                    }
-                    if (parent.fields.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateValueExtensionError)('input', factory.parentTypeName, name));
-                        return;
-                    }
-                    parent.fields.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
-                        name,
-                        node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
-                    });
-                },
-                leave() {
-                    factory.argumentName = '';
-                    // Only reset childName and lastNodeKind if this input value was NOT an argument
-                    if (factory.lastChildNodeKind === graphql_1.Kind.INPUT_VALUE_DEFINITION) {
-                        factory.childName = '';
-                        factory.lastChildNodeKind = graphql_1.Kind.NULL;
-                    }
-                },
-            },
-            InterfaceTypeDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    factory.parentTypeName = name;
-                    factory.lastParentNodeKind = node.kind;
-                    if ((0, utils_1.isNodeExtension)(node)) {
-                        return factory.handleObjectLikeExtension(node);
-                    }
-                    if (factory.parentContainerByTypeName.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
-                        return false;
-                    }
-                    const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-                    factory.parentContainerByTypeName.set(name, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                        fields: new Map(),
-                        interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
-                        isEntity,
-                        kind: node.kind,
-                        name: node.name,
-                    });
-                    if (!isEntity) {
-                        return;
-                    }
-                    factory.entityInterfaces.set(name, {
-                        concreteTypeNames: new Set(),
-                        interfaceFieldNames: new Set(node.fields?.map((field) => field.name.value)),
-                        interfaceObjectFieldNames: new Set(),
-                        isInterfaceObject: false,
-                        typeName: name,
-                    });
-                    (0, utils_3.upsertEntityContainerProperties)(factory.entityContainerByTypeName, {
-                        typeName: factory.parentTypeName,
-                        ...(factory.subgraphName ? { subgraphNames: [factory.subgraphName] } : {}),
-                    });
-                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, name, utils_2.newFieldSetContainer);
-                    factory.extractKeyFieldSets(node, fieldSetContainer);
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                    factory.isCurrentParentExtension = false;
-                },
-            },
-            InterfaceTypeExtension: {
-                enter(node) {
-                    factory.parentTypeName = node.name.value;
-                    factory.lastParentNodeKind = node.kind;
-                    return factory.handleObjectLikeExtension(node);
-                },
-                leave() {
-                    factory.isCurrentParentExtension = false;
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            ObjectTypeDefinition: {
-                enter(node) {
-                    const typeName = node.name.value;
-                    if (typeName === string_constants_1.SERVICE_OBJECT) {
-                        return false;
-                    }
-                    factory.isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(typeName) || factory.operationTypeNames.has(typeName);
-                    factory.parentTypeName = typeName;
-                    factory.lastParentNodeKind = node.kind;
-                    (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
-                    factory.handleInterfaceObject(node);
-                    // handling for @extends directive
-                    if ((0, utils_1.isNodeExtension)(node)) {
-                        return factory.handleObjectLikeExtension(node);
-                    }
-                    if (factory.parentContainerByTypeName.has(typeName)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), typeName));
-                        return false;
-                    }
-                    const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-                    factory.parentContainerByTypeName.set(typeName, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                        fields: new Map(),
-                        interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
-                        isEntity,
-                        kind: node.kind,
-                        name: node.name,
-                    });
-                    if (!isEntity) {
-                        return;
-                    }
-                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, typeName, utils_2.newFieldSetContainer);
-                    factory.extractKeyFieldSets(node, fieldSetContainer);
-                    (0, utils_3.upsertEntityContainerProperties)(factory.entityContainerByTypeName, {
-                        typeName: factory.parentTypeName,
-                        keyFieldSets: fieldSetContainer.keys,
-                        ...(factory.subgraphName ? { subgraphNames: [factory.subgraphName] } : {}),
-                    });
-                },
-                leave() {
-                    factory.isCurrentParentRootType = false;
-                    factory.isCurrentParentExtension = false;
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            ObjectTypeExtension: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.SERVICE_OBJECT) {
-                        return false;
-                    }
-                    factory.isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name) || factory.operationTypeNames.has(name);
-                    factory.parentTypeName = name;
-                    factory.lastParentNodeKind = node.kind;
-                    (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
-                    return factory.handleObjectLikeExtension(node);
-                },
-                leave() {
-                    factory.isCurrentParentRootType = false;
-                    factory.isCurrentParentExtension = false;
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            ScalarTypeDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.ANY_SCALAR) {
-                        return false;
-                    }
-                    const parent = factory.parentContainerByTypeName.get(name);
-                    if (parent) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
-                        return false;
-                    }
-                    factory.parentTypeName = name;
-                    factory.lastParentNodeKind = node.kind;
-                    factory.parentContainerByTypeName.set(name, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                        kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
-                        name: node.name,
-                    });
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            ScalarTypeExtension: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.ANY_SCALAR) {
-                        return false;
-                    }
-                    const extension = factory.extensionContainerByTypeName.get(name);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectivesAndAuthorization(node, extension.directives);
-                    }
-                    else {
-                        factory.parentTypeName = name;
-                        factory.lastParentNodeKind = node.kind;
-                        factory.extensionContainerByTypeName.set(name, {
-                            directives: factory.extractDirectivesAndAuthorization(node, new Map()),
-                            kind: node.kind,
-                            name: node.name,
-                        });
-                    }
-                    return false;
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            UnionTypeDefinition: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.ENTITY_UNION) {
-                        return false;
-                    }
-                    factory.parentTypeName = name;
-                    const parent = factory.parentContainerByTypeName.get(name);
-                    if (parent) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
-                        return false;
-                    }
-                    if (!node.types) {
-                        factory.errors.push((0, errors_1.noDefinedUnionMembersError)(name));
-                        return false;
-                    }
-                    factory.lastParentNodeKind = node.kind;
-                    (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
-                    factory.parentContainerByTypeName.set(name, {
-                        description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
-                        kind: node.kind,
-                        name: node.name,
-                        types: factory.extractUniqueUnionMembers([...node.types], new Map()),
-                    });
-                },
-                leave() {
-                    factory.parentTypeName = '';
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-            UnionTypeExtension: {
-                enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.ENTITY_UNION) {
-                        return false;
-                    }
-                    const extension = factory.extensionContainerByTypeName.get(name);
-                    if (!node.types) {
-                        factory.errors.push();
-                        return false;
-                    }
-                    factory.lastParentNodeKind = node.kind;
-                    (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.UNION_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectives(node, extension.directives);
-                    }
-                    else {
-                        factory.extensionContainerByTypeName.set(name, {
-                            directives: factory.extractDirectives(node, new Map()),
-                            kind: node.kind,
-                            name: node.name,
-                            types: factory.extractUniqueUnionMembers([...node.types], new Map()),
-                        });
+        (0, walkers_1.upsertDirectiveAndSchemaDefinitions)(this, document);
+        (0, walkers_1.upsertParentsAndChildren)(this, document);
+        (0, walkers_1.consolidateAuthorizationDirectives)(this, document);
+        for (const interfaceTypeName of this.interfaceTypeNamesWithAuthorizationDirectives) {
+            const interfaceAuthorizationData = this.authorizationDataByParentTypeName.get(interfaceTypeName);
+            if (!interfaceAuthorizationData) {
+                continue;
+            }
+            const concreteTypeNames = this.abstractToConcreteTypeNames.get(interfaceTypeName);
+            for (const concreteTypeName of concreteTypeNames || []) {
+                const concreteAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_3.newAuthorizationData)(concreteTypeName));
+                for (const [fieldName, interfaceFieldAuthorizationData,] of interfaceAuthorizationData.fieldAuthorizationDataByFieldName) {
+                    if (!(0, utils_3.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, interfaceFieldAuthorizationData)) {
+                        this.invalidOrScopesHostPaths.add(`${concreteTypeName}.${fieldName}`);
                     }
-                    return false;
-                },
-                leave() {
-                    factory.lastParentNodeKind = graphql_1.Kind.NULL;
-                },
-            },
-        });
+                }
+            }
+        }
+        // Apply inherited leaf authorization that was not applied to interface fields of that type earlier
+        for (const [typeName, fieldAuthorizationDatas] of this.heirFieldAuthorizationDataByTypeName) {
+            const authorizationData = this.authorizationDataByParentTypeName.get(typeName);
+            if (!authorizationData) {
+                continue;
+            }
+            for (const fieldAuthorizationData of fieldAuthorizationDatas) {
+                if (!(0, utils_3.mergeAuthorizationDataByAND)(authorizationData, fieldAuthorizationData)) {
+                    this.invalidOrScopesHostPaths.add(`${typeName}.${fieldAuthorizationData.fieldName}`);
+                }
+            }
+        }
+        if (this.invalidOrScopesHostPaths.size > 0) {
+            this.errors.push((0, errors_1.orScopesLimitError)(utils_3.maxOrScopes, [...this.invalidOrScopesHostPaths]));
+        }
         const definitions = [];
         for (const directiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
             definitions.push(directiveDefinition);
         }
         definitions.push(constants_1.FIELD_SET_SCALAR_DEFINITION);
-        if (factory.isSubgraphVersionTwo) {
+        if (this.isSubgraphVersionTwo) {
             for (const directiveDefinition of constants_1.VERSION_TWO_DIRECTIVE_DEFINITIONS) {
                 definitions.push(directiveDefinition);
-                this.allDirectiveDefinitions.set(directiveDefinition.name.value, directiveDefinition);
+                this.directiveDefinitionByDirectiveName.set(directiveDefinition.name.value, directiveDefinition);
             }
             definitions.push(constants_1.SCOPE_SCALAR_DEFINITION);
         }
@@ -1311,11 +602,11 @@ class NormalizationFactory {
             definitions.push(directiveDefinition);
         }
         if (this.schemaDefinition.operationTypes.size > 0) {
-            definitions.push((0, utils_2.schemaContainerToNode)(this, this.schemaDefinition));
+            definitions.push((0, utils_4.getSchemaNodeByData)(this.schemaDefinition, this.errors, this.directiveDefinitionByDirectiveName));
         }
         const validExtensionOrphans = new Set();
         const parentsToIgnore = new Set();
-        for (const [extensionTypeName, extensionContainer] of this.extensionContainerByTypeName) {
+        for (const [extensionTypeName, parentExtensionData] of this.parentExtensionDataByTypeName) {
             const isEntity = this.entityContainerByTypeName.has(extensionTypeName);
             const configurationData = {
                 fieldNames: new Set(),
@@ -1323,91 +614,91 @@ class NormalizationFactory {
                 typeName: extensionTypeName,
             };
             this.configurationDataMap.set(extensionTypeName, configurationData);
-            if (extensionContainer.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            if (parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                 if (this.operationTypeNames.has(extensionTypeName)) {
-                    extensionContainer.fields.delete(string_constants_1.SERVICE_FIELD);
-                    extensionContainer.fields.delete(string_constants_1.ENTITIES_FIELD);
+                    parentExtensionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
+                    parentExtensionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                 }
-                (0, utils_2.addNonExternalFieldsToSet)(extensionContainer.fields, configurationData.fieldNames);
+                (0, utils_2.addNonExternalFieldsToSet)(parentExtensionData.fieldDataByFieldName, configurationData.fieldNames);
             }
-            const baseType = this.parentContainerByTypeName.get(extensionTypeName);
-            if (!baseType) {
-                if (extensionContainer.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            const parentDefinitionData = this.parentDefinitionDataByTypeName.get(extensionTypeName);
+            if (!parentDefinitionData) {
+                if (parentExtensionData.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                     this.errors.push((0, errors_1.noBaseTypeExtensionError)(extensionTypeName));
                 }
                 else {
-                    this.validateInterfaceImplementations(extensionContainer);
+                    this.validateInterfaceImplementations(parentExtensionData);
                     validExtensionOrphans.add(extensionTypeName);
-                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, extensionContainer));
+                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentExtensionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                 }
                 continue;
             }
-            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extensionContainer.kind, extensionTypeName)) {
-                this.errors.push((0, errors_1.incompatibleExtensionError)(extensionTypeName, baseType.kind, extensionContainer.kind));
+            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(parentDefinitionData.kind, parentExtensionData.kind, extensionTypeName)) {
+                this.errors.push((0, errors_1.incompatibleExtensionError)(extensionTypeName, parentDefinitionData.kind, parentExtensionData.kind));
                 continue;
             }
-            switch (baseType.kind) {
+            switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    const enumExtension = extensionContainer;
-                    for (const [valueName, enumValueDefinitionNode] of enumExtension.values) {
-                        if (!baseType.values.has(valueName)) {
-                            baseType.values.set(valueName, enumValueDefinitionNode);
+                    const enumExtensionData = parentExtensionData;
+                    for (const [valueName, enumValueDefinitionNode] of enumExtensionData.enumValueDataByValueName) {
+                        if (!parentDefinitionData.enumValueDataByValueName.has(valueName)) {
+                            parentDefinitionData.enumValueDataByValueName.set(valueName, enumValueDefinitionNode);
                             continue;
                         }
                         this.errors.push((0, errors_1.duplicateEnumValueDefinitionError)(valueName, extensionTypeName));
                     }
-                    definitions.push((0, utils_2.enumContainerToNode)(this, baseType, enumExtension));
+                    definitions.push((0, utils_4.getEnumNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, enumExtensionData));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    const inputExtension = extensionContainer;
-                    for (const [fieldName, inputValueDefinitionNode] of inputExtension.fields) {
-                        if (!baseType.fields.has(fieldName)) {
-                            baseType.fields.set(fieldName, inputValueDefinitionNode);
+                    const inputObjectExtensionData = parentExtensionData;
+                    for (const [fieldName, inputValueDefinitionNode] of inputObjectExtensionData.inputValueDataByValueName) {
+                        if (!parentDefinitionData.inputValueDataByValueName.has(fieldName)) {
+                            parentDefinitionData.inputValueDataByValueName.set(fieldName, inputValueDefinitionNode);
                             continue;
                         }
                         this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
                     }
-                    definitions.push((0, utils_2.inputObjectContainerToNode)(this, baseType, inputExtension));
+                    definitions.push((0, utils_4.getInputObjectNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, inputObjectExtensionData));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const objectLikeExtension = extensionContainer;
+                    const extensionWithFieldsData = parentExtensionData;
                     const operationTypeNode = this.operationTypeNames.get(extensionTypeName);
                     if (operationTypeNode) {
-                        objectLikeExtension.fields.delete(string_constants_1.SERVICE_FIELD);
-                        objectLikeExtension.fields.delete(string_constants_1.ENTITIES_FIELD);
+                        extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
+                        extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                     }
-                    for (const [fieldName, fieldContainer] of objectLikeExtension.fields) {
-                        if (fieldContainer.arguments.size > 0) {
+                    for (const [fieldName, fieldData] of extensionWithFieldsData.fieldDataByFieldName) {
+                        if (fieldData.argumentDataByArgumentName.size > 0) {
                             // Arguments can only be fully validated once all parents types are known
-                            this.validateArguments(fieldContainer, `${extensionTypeName}.${fieldName}`);
+                            this.validateArguments(fieldData, `${extensionTypeName}.${fieldName}`);
                         }
-                        if (baseType.fields.has(fieldName)) {
+                        if (parentDefinitionData.fieldDataByFieldName.has(fieldName)) {
                             this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
                             continue;
                         }
-                        baseType.fields.set(fieldName, fieldContainer);
-                        if (!fieldContainer.arguments.has(string_constants_1.EXTERNAL)) {
+                        parentDefinitionData.fieldDataByFieldName.set(fieldName, fieldData);
+                        if (!fieldData.argumentDataByArgumentName.has(string_constants_1.EXTERNAL)) {
                             configurationData.fieldNames.add(fieldName);
                         }
                     }
-                    this.mergeUniqueInterfaces(objectLikeExtension.interfaces, baseType.interfaces, extensionTypeName);
-                    this.validateInterfaceImplementations(baseType);
-                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, baseType, objectLikeExtension));
+                    this.mergeUniqueInterfaces(extensionWithFieldsData.implementedInterfaceTypeNames, parentDefinitionData.implementedInterfaceTypeNames, extensionTypeName);
+                    this.validateInterfaceImplementations(parentDefinitionData);
+                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, extensionWithFieldsData));
                     // Interfaces and objects must define at least one field
-                    if (baseType.fields.size < 1 && !(0, utils_2.isNodeQuery)(extensionTypeName, operationTypeNode)) {
-                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(baseType.kind), extensionTypeName));
+                    if (parentDefinitionData.fieldDataByFieldName.size < 1 &&
+                        !(0, utils_2.isNodeQuery)(extensionTypeName, operationTypeNode)) {
+                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), extensionTypeName));
                     }
                     // Add the non-external base type field names to the configuration data
-                    (0, utils_2.addNonExternalFieldsToSet)(baseType.fields, configurationData.fieldNames);
+                    (0, utils_2.addNonExternalFieldsToSet)(parentDefinitionData.fieldDataByFieldName, configurationData.fieldNames);
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions.push((0, utils_2.scalarContainerToNode)(this, baseType, extensionContainer));
+                    definitions.push((0, utils_4.getScalarNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, parentExtensionData));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    const unionExtension = extensionContainer;
-                    definitions.push((0, utils_2.unionContainerToNode)(this, baseType, unionExtension));
+                    definitions.push((0, utils_4.getUnionNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, parentExtensionData));
                     break;
                 default:
                     throw (0, errors_1.unexpectedKindFatalError)(extensionTypeName);
@@ -1415,16 +706,16 @@ class NormalizationFactory {
             // At this point, the base type has been dealt with, so it doesn't need to be dealt with again
             parentsToIgnore.add(extensionTypeName);
         }
-        for (const [parentTypeName, parentContainer] of this.parentContainerByTypeName) {
+        for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
             if (parentsToIgnore.has(parentTypeName)) {
                 continue;
             }
-            switch (parentContainer.kind) {
+            switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    definitions.push((0, utils_2.enumContainerToNode)(this, parentContainer));
+                    definitions.push((0, utils_4.getEnumNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    definitions.push((0, utils_2.inputObjectContainerToNode)(this, parentContainer));
+                    definitions.push((0, utils_4.getInputObjectNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
@@ -1432,15 +723,15 @@ class NormalizationFactory {
                     const isEntity = this.entityContainerByTypeName.has(parentTypeName);
                     const operationTypeNode = this.operationTypeNames.get(parentTypeName);
                     if (operationTypeNode) {
-                        parentContainer.fields.delete(string_constants_1.SERVICE_FIELD);
-                        parentContainer.fields.delete(string_constants_1.ENTITIES_FIELD);
+                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
+                        parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                     }
                     if (this.parentsWithChildArguments.has(parentTypeName)) {
-                        if (parentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
-                            parentContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                        if (parentDefinitionData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                            parentDefinitionData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                             continue;
                         }
-                        for (const [fieldName, fieldContainer] of parentContainer.fields) {
+                        for (const [fieldName, fieldContainer] of parentDefinitionData.fieldDataByFieldName) {
                             // Arguments can only be fully validated once all parents types are known
                             this.validateArguments(fieldContainer, `${parentTypeName}.${fieldName}`);
                         }
@@ -1462,19 +753,19 @@ class NormalizationFactory {
                         configurationData.events = events;
                     }
                     this.configurationDataMap.set(parentTypeName, configurationData);
-                    (0, utils_2.addNonExternalFieldsToSet)(parentContainer.fields, configurationData.fieldNames);
-                    this.validateInterfaceImplementations(parentContainer);
-                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, parentContainer));
+                    (0, utils_2.addNonExternalFieldsToSet)(parentDefinitionData.fieldDataByFieldName, configurationData.fieldNames);
+                    this.validateInterfaceImplementations(parentDefinitionData);
+                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     // interfaces and objects must define at least one field
-                    if (parentContainer.fields.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
-                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentContainer.kind), parentTypeName));
+                    if (parentDefinitionData.fieldDataByFieldName.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
+                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
                     }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions.push((0, utils_2.scalarContainerToNode)(this, parentContainer));
+                    definitions.push((0, utils_4.getScalarNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    definitions.push((0, utils_2.unionContainerToNode)(this, parentContainer));
+                    definitions.push((0, utils_4.getUnionNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName));
                     break;
                 default:
                     throw (0, errors_1.unexpectedKindFatalError)(parentTypeName);
@@ -1488,12 +779,13 @@ class NormalizationFactory {
             const operationTypeName = node ? (0, type_merging_1.getNamedTypeForChild)(`schema.${operationType}`, node.type) : defaultTypeName;
             // If a custom type is used, the default type should not be defined
             if (operationTypeName !== defaultTypeName &&
-                (this.parentContainerByTypeName.has(defaultTypeName) || this.extensionContainerByTypeName.has(defaultTypeName))) {
+                (this.parentDefinitionDataByTypeName.has(defaultTypeName) ||
+                    this.parentExtensionDataByTypeName.has(defaultTypeName))) {
                 this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
                 continue;
             }
-            const object = this.parentContainerByTypeName.get(operationTypeName);
-            const extension = this.extensionContainerByTypeName.get(operationTypeName);
+            const object = this.parentDefinitionDataByTypeName.get(operationTypeName);
+            const extension = this.parentExtensionDataByTypeName.get(operationTypeName);
             // Node is truthy if an operation type was explicitly declared
             if (node) {
                 // If the type is not defined in the schema, it's always an error
@@ -1523,12 +815,11 @@ class NormalizationFactory {
                 }
                 // Root types fields whose response type is an extension orphan could be valid through a federated graph
                 // However, the field would have to be shareable to ever be valid TODO
-                for (const fieldContainer of container.fields.values()) {
-                    const fieldName = fieldContainer.name;
+                for (const [fieldName, fieldData] of container.fieldDataByFieldName) {
                     const fieldPath = `${operationTypeName}.${fieldName}`;
-                    const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.node.type);
+                    const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldData.node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldTypeName) &&
-                        !this.parentContainerByTypeName.has(fieldTypeName) &&
+                        !this.parentDefinitionDataByTypeName.has(fieldTypeName) &&
                         !validExtensionOrphans.has(fieldTypeName)) {
                         this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
                     }
@@ -1536,17 +827,18 @@ class NormalizationFactory {
             }
         }
         for (const referencedTypeName of this.referencedTypeNames) {
-            if (this.parentContainerByTypeName.has(referencedTypeName) ||
+            if (this.parentDefinitionDataByTypeName.has(referencedTypeName) ||
                 this.entityContainerByTypeName.has(referencedTypeName)) {
                 continue;
             }
-            const extension = this.extensionContainerByTypeName.get(referencedTypeName);
+            const extension = this.parentExtensionDataByTypeName.get(referencedTypeName);
             if (!extension || extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }
         for (const [parentTypeName, fieldSetContainers] of this.fieldSetContainerByTypeName) {
-            const parentContainer = this.parentContainerByTypeName.get(parentTypeName) || this.extensionContainerByTypeName.get(parentTypeName);
+            const parentContainer = this.parentDefinitionDataByTypeName.get(parentTypeName) ||
+                this.parentExtensionDataByTypeName.get(parentTypeName);
             if (!parentContainer ||
                 (parentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
                     parentContainer.kind != graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
@@ -1565,7 +857,6 @@ class NormalizationFactory {
             kind: graphql_1.Kind.DOCUMENT,
             definitions,
         };
-        (0, subgraph_1.walkSubgraphToApplyFieldAuthorization)(factory, newAST);
         return {
             normalizationResult: {
                 authorizationDataByParentTypeName: this.authorizationDataByParentTypeName,
@@ -1574,12 +865,12 @@ class NormalizationFactory {
                 configurationDataMap: this.configurationDataMap,
                 entityContainerByTypeName: this.entityContainerByTypeName,
                 entityInterfaces: this.entityInterfaces,
-                extensionContainerByTypeName: this.extensionContainerByTypeName,
+                parentExtensionDataByTypeName: this.parentExtensionDataByTypeName,
                 isVersionTwo: this.isSubgraphVersionTwo,
                 keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
                 operationTypes: this.operationTypeNames,
                 overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
-                parentContainerByTypeName: this.parentContainerByTypeName,
+                parentDataByTypeName: this.parentDefinitionDataByTypeName,
                 subgraphAST: newAST,
                 subgraphString: (0, graphql_1.print)(newAST),
                 schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true }),
@@ -1595,10 +886,11 @@ function batchNormalize(subgraphs) {
     const allOverridesByTargetSubgraphName = new Map();
     const overrideSourceSubgraphNamesByFieldPath = new Map();
     const duplicateOverriddenFieldPaths = new Set();
-    const parentContainerMapsBySubgraphName = new Map();
+    const parentDefinitionDataMapsBySubgraphName = new Map();
     const subgraphNames = new Set();
     const nonUniqueSubgraphNames = new Set();
     const invalidNameErrorMessages = [];
+    const invalidOrScopesHostPaths = new Set();
     const warnings = [];
     const validationErrors = [];
     // Record the subgraph names first, so that subgraph references can be validated
@@ -1622,9 +914,9 @@ function batchNormalize(subgraphs) {
             validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, [errors_1.subgraphValidationFailureError]));
             continue;
         }
-        parentContainerMapsBySubgraphName.set(subgraphName, normalizationResult.parentContainerByTypeName);
+        parentDefinitionDataMapsBySubgraphName.set(subgraphName, normalizationResult.parentDataByTypeName);
         for (const authorizationData of normalizationResult.authorizationDataByParentTypeName.values()) {
-            (0, utils_3.upsertAuthorizationData)(authorizationDataByParentTypeName, authorizationData);
+            (0, utils_3.upsertAuthorizationData)(authorizationDataByParentTypeName, authorizationData, invalidOrScopesHostPaths);
         }
         for (const entityContainer of normalizationResult.entityContainerByTypeName.values()) {
             (0, utils_3.upsertEntityContainer)(entityContainerByTypeName, entityContainer);
@@ -1634,13 +926,13 @@ function batchNormalize(subgraphs) {
                 configurationDataMap: normalizationResult.configurationDataMap,
                 definitions: normalizationResult.subgraphAST,
                 entityInterfaces: normalizationResult.entityInterfaces,
-                extensionContainerByTypeName: normalizationResult.extensionContainerByTypeName,
+                parentExtensionDataByTypeName: normalizationResult.parentExtensionDataByTypeName,
                 keyFieldNamesByParentTypeName: normalizationResult.keyFieldNamesByParentTypeName,
                 isVersionTwo: normalizationResult.isVersionTwo,
                 name: subgraphName,
                 operationTypes: normalizationResult.operationTypes,
                 overriddenFieldNamesByParentTypeName: new Map(),
-                parentContainerByTypeName: normalizationResult.parentContainerByTypeName,
+                parentDataByTypeName: normalizationResult.parentDataByTypeName,
                 schema: normalizationResult.schema,
                 url: subgraph.url,
             });
@@ -1673,6 +965,9 @@ function batchNormalize(subgraphs) {
         }
     }
     const allErrors = [];
+    if (invalidOrScopesHostPaths.size > 0) {
+        allErrors.push((0, errors_1.orScopesLimitError)(utils_3.maxOrScopes, [...invalidOrScopesHostPaths]));
+    }
     if (invalidNameErrorMessages.length > 0 || nonUniqueSubgraphNames.size > 0) {
         allErrors.push((0, errors_1.invalidSubgraphNamesError)([...nonUniqueSubgraphNames], invalidNameErrorMessages));
     }