@wundergraph/composition 0.18.4 → 0.19.0

package/dist/normalization/normalization-factory.js

@@ -5,42 +5,43 @@ 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("../schema-building/type-merging");
 const utils_3 = require("../utils/utils");
 const errors_1 = require("../errors/errors");
 const string_constants_1 = require("../utils/string-constants");
 const buildASTSchema_1 = require("../buildASTSchema/buildASTSchema");
 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");
+const graphology_1 = require("graphology");
+const ast_1 = require("../schema-building/ast");
 function normalizeSubgraphFromString(subgraphSDL) {
     const { error, documentNode } = (0, utils_1.safeParse)(subgraphSDL);
     if (error || !documentNode) {
         return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(error)] };
     }
-    const normalizationFactory = new NormalizationFactory();
+    const normalizationFactory = new NormalizationFactory(new graphology_1.MultiGraph());
     return normalizationFactory.normalize(documentNode);
 }
 exports.normalizeSubgraphFromString = normalizeSubgraphFromString;
-function normalizeSubgraph(document, subgraphName) {
-    const normalizationFactory = new NormalizationFactory(subgraphName);
+function normalizeSubgraph(document, graph, subgraphName) {
+    const normalizationFactory = new NormalizationFactory(graph || new graphology_1.MultiGraph(), subgraphName);
     return normalizationFactory.normalize(document);
 }
 exports.normalizeSubgraph = normalizeSubgraph;
 class NormalizationFactory {
-    abstractToConcreteTypeNames = new Map();
-    directiveDefinitionByDirectiveName = new Map();
     argumentName = '';
     authorizationDataByParentTypeName = new Map();
     childName = '';
-    configurationDataMap = new Map();
+    concreteTypeNamesByAbstractTypeName = new Map();
+    configurationDataByParentTypeName = new Map();
     customDirectiveDefinitions = new Map();
+    directiveDefinitionByDirectiveName = new Map();
     errors = [];
     entityContainerByTypeName = new Map();
     entityInterfaces = new Map();
+    graph;
     parentExtensionDataByTypeName = new Map();
     interfaceTypeNamesWithAuthorizationDirectives = new Set();
     isCurrentParentExtension = false;
@@ -52,9 +53,10 @@ class NormalizationFactory {
     lastChildNodeKind = graphql_1.Kind.NULL;
     leafTypeNamesWithAuthorizationDirectives = new Set();
     keyFieldNamesByParentTypeName = new Map();
-    operationTypeNames = new Map();
+    operationTypeNodeByTypeName = new Map();
+    originalTypeNameByRenamedTypeName = new Map();
     parentDefinitionDataByTypeName = new Map();
-    parentTypeName = '';
+    originalParentTypeName = '';
     parentsWithChildArguments = new Set();
     eventsConfigurations = new Map();
     overridesByTargetSubgraphName = new Map();
@@ -62,13 +64,15 @@ class NormalizationFactory {
     schemaDefinition;
     referencedDirectiveNames = new Set();
     referencedTypeNames = new Set();
+    renamedParentTypeName = '';
     warnings = [];
     subgraphName;
-    constructor(subgraphName) {
+    constructor(graph, subgraphName) {
         for (const [baseDirectiveName, baseDirectiveDefinition] of constants_1.BASE_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME) {
             this.directiveDefinitionByDirectiveName.set(baseDirectiveName, baseDirectiveDefinition);
         }
-        this.subgraphName = subgraphName;
+        this.graph = graph;
+        this.subgraphName = subgraphName || string_constants_1.N_A;
         this.schemaDefinition = {
             directivesByDirectiveName: new Map(),
             kind: graphql_1.Kind.SCHEMA_DEFINITION,
@@ -94,32 +98,18 @@ class NormalizationFactory {
                 return { hasUnhandledError: true, typeString: (0, utils_3.kindToTypeString)(parentContainer.kind) };
         }
     }
-    extractArguments(node, argumentDataByArgumentName, fieldPath) {
-        if (!node.arguments) {
-            return argumentDataByArgumentName;
-        }
-        this.parentsWithChildArguments.add(this.parentTypeName);
-        const duplicatedArguments = new Set();
-        for (const argumentNode of node.arguments) {
-            const argumentName = argumentNode.name.value;
-            if (argumentDataByArgumentName.has(argumentName)) {
-                duplicatedArguments.add(argumentName);
-                continue;
-            }
-            argumentDataByArgumentName.set(argumentName, (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.parentTypeName));
-        }
-        if (duplicatedArguments.size > 0) {
-            this.errors.push((0, errors_1.duplicateArgumentsError)(fieldPath, [...duplicatedArguments]));
-        }
-        return argumentDataByArgumentName;
-    }
     validateArguments(fieldData, fieldPath) {
         const invalidArguments = [];
         for (const [argumentName, argumentNode] of fieldData.argumentDataByArgumentName) {
-            const namedType = (0, type_merging_1.getNamedTypeForChild)(fieldPath + `(${argumentName}...)`, argumentNode.type);
-            const { hasUnhandledError, typeString } = this.validateInputNamedType(namedType);
+            const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(argumentNode.type);
+            const { hasUnhandledError, typeString } = this.validateInputNamedType(namedTypeName);
             if (hasUnhandledError) {
-                invalidArguments.push({ argumentName, namedType, typeString, typeName: (0, merge_1.printTypeNode)(argumentNode.type) });
+                invalidArguments.push({
+                    argumentName,
+                    namedType: namedTypeName,
+                    typeString,
+                    typeName: (0, merge_1.printTypeNode)(argumentNode.type),
+                });
             }
         }
         if (invalidArguments.length > 0) {
@@ -128,7 +118,8 @@ class NormalizationFactory {
     }
     // Note that directive validation errors are handled elsewhere
     getAuthorizationData(node) {
-        let authorizationData = this.authorizationDataByParentTypeName.get(this.parentTypeName);
+        const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
+        let authorizationData = this.authorizationDataByParentTypeName.get(parentTypeName);
         (0, utils_3.resetAuthorizationData)(authorizationData);
         if (!node.directives) {
             return authorizationData;
@@ -158,10 +149,10 @@ class NormalizationFactory {
             return authorizationData;
         }
         if ((0, utils_3.isNodeKindInterface)(node.kind)) {
-            this.interfaceTypeNamesWithAuthorizationDirectives.add(this.parentTypeName);
+            this.interfaceTypeNamesWithAuthorizationDirectives.add(parentTypeName);
         }
         if (!authorizationData) {
-            authorizationData = (0, utils_3.setAndGetValue)(this.authorizationDataByParentTypeName, this.parentTypeName, (0, utils_3.newAuthorizationData)(this.parentTypeName));
+            authorizationData = (0, utils_3.setAndGetValue)(this.authorizationDataByParentTypeName, this.renamedParentTypeName || this.originalParentTypeName, (0, utils_3.newAuthorizationData)(parentTypeName));
         }
         authorizationData.hasParentLevelAuthorization = true;
         authorizationData.requiresAuthentication = requiresAuthentication;
@@ -181,7 +172,7 @@ class NormalizationFactory {
             return authorizationData;
         }
         if (orScopes.length > utils_3.maxOrScopes) {
-            this.invalidOrScopesHostPaths.add(this.parentTypeName);
+            this.invalidOrScopesHostPaths.add(this.originalParentTypeName);
             return;
         }
         for (const scopes of orScopes) {
@@ -205,7 +196,7 @@ class NormalizationFactory {
         if (!node.directives) {
             return directivesByDirectiveName;
         }
-        const hostPath = this.childName ? `${this.parentTypeName}.${this.childName}` : this.parentTypeName;
+        const hostPath = this.childName ? `${this.originalParentTypeName}.${this.childName}` : this.originalParentTypeName;
         const authorizationDirectives = [];
         for (const directiveNode of node.directives) {
             const errorMessages = (0, utils_4.getDirectiveValidationErrors)(directiveNode, node.kind, directivesByDirectiveName, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, hostPath);
@@ -237,10 +228,11 @@ class NormalizationFactory {
         if (authorizationDirectives.length < 1) {
             return directivesByDirectiveName;
         }
+        const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
         if (node.kind !== graphql_1.Kind.FIELD_DEFINITION) {
-            this.leafTypeNamesWithAuthorizationDirectives.add(this.parentTypeName);
+            this.leafTypeNamesWithAuthorizationDirectives.add(parentTypeName);
         }
-        const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, this.parentTypeName, () => (0, utils_3.newAuthorizationData)(this.parentTypeName));
+        const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, parentTypeName, () => (0, utils_3.newAuthorizationData)(parentTypeName));
         const authorizationData = (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, node, this.childName);
         for (const directiveNode of authorizationDirectives) {
             const directiveName = directiveNode.name.value;
@@ -290,65 +282,33 @@ class NormalizationFactory {
             typeName: name,
         });
     }
-    handleExtensionWithFields(node) {
+    handleExtensionWithFields(node, isRootType = false) {
         this.isCurrentParentExtension = true;
-        const extension = this.parentExtensionDataByTypeName.get(this.parentTypeName);
+        const parentExtensionData = this.parentExtensionDataByTypeName.get(this.originalParentTypeName);
         const convertedKind = (0, utils_4.convertKindForExtension)(node);
-        if (extension) {
-            if (extension.kind !== convertedKind) {
-                this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+        if (parentExtensionData) {
+            if (parentExtensionData.kind !== convertedKind) {
+                this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, parentExtensionData.kind));
                 return false;
             }
-            (0, utils_4.extractDirectives)(node, extension.directivesByDirectiveName, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, this.parentTypeName);
-            (0, utils_1.extractInterfaces)(node, extension.implementedInterfaceTypeNames, this.errors);
+            (0, utils_4.extractDirectives)(node, parentExtensionData.directivesByDirectiveName, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, this.originalParentTypeName);
+            (0, utils_1.extractInterfaces)(node, parentExtensionData.implementedInterfaceTypeNames, this.errors);
             return;
         }
         const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-        (0, utils_4.upsertExtensionWithFieldsDataByNode)(this.parentExtensionDataByTypeName, node, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, isEntity);
+        (0, utils_4.addExtensionWithFieldsDataByNode)(this.parentExtensionDataByTypeName, node, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, isEntity, isRootType, this.subgraphName, this.renamedParentTypeName);
         // TODO re-assess this line
         if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION || !isEntity) {
             return;
         }
-        const fieldSetContainer = (0, utils_3.getValueOrDefault)(this.fieldSetContainerByTypeName, this.parentTypeName, utils_2.newFieldSetContainer);
+        const fieldSetContainer = (0, utils_3.getValueOrDefault)(this.fieldSetContainerByTypeName, this.originalParentTypeName, utils_2.newFieldSetContainer);
         this.extractKeyFieldSets(node, fieldSetContainer);
         (0, utils_3.upsertEntityContainerProperties)(this.entityContainerByTypeName, {
-            typeName: this.parentTypeName,
+            typeName: this.originalParentTypeName,
             keyFieldSets: fieldSetContainer.keys,
             ...(this.subgraphName ? { subgraphNames: [this.subgraphName] } : {}),
         });
     }
-    isTypeValidImplementation(originalType, implementationType) {
-        if (originalType.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            if (implementationType.kind !== graphql_1.Kind.NON_NULL_TYPE) {
-                return false;
-            }
-            return this.isTypeValidImplementation(originalType.type, implementationType.type);
-        }
-        if (implementationType.kind === graphql_1.Kind.NON_NULL_TYPE) {
-            return this.isTypeValidImplementation(originalType, implementationType.type);
-        }
-        switch (originalType.kind) {
-            case graphql_1.Kind.NAMED_TYPE:
-                if (implementationType.kind === graphql_1.Kind.NAMED_TYPE) {
-                    const originalTypeName = originalType.name.value;
-                    const implementationTypeName = implementationType.name.value;
-                    if (originalTypeName === implementationTypeName) {
-                        return true;
-                    }
-                    const concreteTypes = this.abstractToConcreteTypeNames.get(originalTypeName);
-                    if (!concreteTypes) {
-                        return false;
-                    }
-                    return concreteTypes.has(implementationTypeName);
-                }
-                return false;
-            default:
-                if (implementationType.kind === graphql_1.Kind.LIST_TYPE) {
-                    return this.isTypeValidImplementation(originalType.type, implementationType.type);
-                }
-                return false;
-        }
-    }
     extractKeyFieldSets(node, fieldSetContainer) {
         const rawFieldSets = fieldSetContainer.keys;
         const parentTypeName = node.name.value;
@@ -419,7 +379,7 @@ class NormalizationFactory {
                     unimplementedArguments: new Set(),
                 };
                 // The implemented field type must be equally or more restrictive than the original interface field type
-                if (!this.isTypeValidImplementation(interfaceField.node.type, containerField.node.type)) {
+                if (!(0, utils_4.isTypeValidImplementation)(interfaceField.node.type, containerField.node.type, this.concreteTypeNamesByAbstractTypeName)) {
                     hasErrors = true;
                     hasNestedErrors = true;
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
@@ -465,7 +425,7 @@ class NormalizationFactory {
             }
         }
         if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.typeName, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
         }
     }
     handleOverrideDeclaration(node, hostPath, errorMessages) {
@@ -480,7 +440,7 @@ class NormalizationFactory {
             return;
         }
         const overrideDataForSubgraph = (0, utils_3.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-        const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.parentTypeName, () => new Set());
+        const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.renamedParentTypeName || this.originalParentTypeName, () => new Set());
         overriddenFieldNamesForParent.add(this.childName);
     }
     extractEventDirectivesToConfiguration(node) {
@@ -539,7 +499,7 @@ class NormalizationFactory {
             if (!topic) {
                 throw new Error(`Event directives must have a topic argument`);
             }
-            const configuration = (0, utils_3.getValueOrDefault)(this.eventsConfigurations, this.parentTypeName, () => []);
+            const configuration = (0, utils_3.getValueOrDefault)(this.eventsConfigurations, this.renamedParentTypeName || this.originalParentTypeName, () => []);
             configuration.push({
                 type: eventType,
                 fieldName: this.childName,
@@ -561,7 +521,7 @@ class NormalizationFactory {
             if (!interfaceAuthorizationData) {
                 continue;
             }
-            const concreteTypeNames = this.abstractToConcreteTypeNames.get(interfaceTypeName);
+            const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.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) {
@@ -604,18 +564,22 @@ class NormalizationFactory {
         if (this.schemaDefinition.operationTypes.size > 0) {
             definitions.push((0, utils_4.getSchemaNodeByData)(this.schemaDefinition, this.errors, this.directiveDefinitionByDirectiveName));
         }
-        const validExtensionOrphans = new Set();
-        const parentsToIgnore = new Set();
+        const validParentExtensionOrphansByTypeName = new Map();
+        const handledParentTypeNames = new Set();
         for (const [extensionTypeName, parentExtensionData] of this.parentExtensionDataByTypeName) {
             const isEntity = this.entityContainerByTypeName.has(extensionTypeName);
+            const newParentTypeName = parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION
+                ? parentExtensionData.renamedTypeName || extensionTypeName
+                : extensionTypeName;
             const configurationData = {
                 fieldNames: new Set(),
                 isRootNode: isEntity,
-                typeName: extensionTypeName,
+                typeName: newParentTypeName,
             };
-            this.configurationDataMap.set(extensionTypeName, configurationData);
+            this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
             if (parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                if (this.operationTypeNames.has(extensionTypeName)) {
+                if (this.operationTypeNodeByTypeName.has(extensionTypeName)) {
+                    configurationData.isRootNode = true;
                     parentExtensionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
                     parentExtensionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                 }
@@ -628,7 +592,7 @@ class NormalizationFactory {
                 }
                 else {
                     this.validateInterfaceImplementations(parentExtensionData);
-                    validExtensionOrphans.add(extensionTypeName);
+                    validParentExtensionOrphansByTypeName.set(extensionTypeName, parentExtensionData);
                     definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentExtensionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                 }
                 continue;
@@ -664,8 +628,9 @@ class NormalizationFactory {
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
                     const extensionWithFieldsData = parentExtensionData;
-                    const operationTypeNode = this.operationTypeNames.get(extensionTypeName);
+                    const operationTypeNode = this.operationTypeNodeByTypeName.get(extensionTypeName);
                     if (operationTypeNode) {
+                        configurationData.isRootNode = true;
                         extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
                         extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
                     }
@@ -704,10 +669,10 @@ class NormalizationFactory {
                     throw (0, errors_1.unexpectedKindFatalError)(extensionTypeName);
             }
             // At this point, the base type has been dealt with, so it doesn't need to be dealt with again
-            parentsToIgnore.add(extensionTypeName);
+            handledParentTypeNames.add(extensionTypeName);
         }
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
-            if (parentsToIgnore.has(parentTypeName)) {
+            if (handledParentTypeNames.has(parentTypeName)) {
                 continue;
             }
             switch (parentDefinitionData.kind) {
@@ -721,7 +686,7 @@ class NormalizationFactory {
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
                     const isEntity = this.entityContainerByTypeName.has(parentTypeName);
-                    const operationTypeNode = this.operationTypeNames.get(parentTypeName);
+                    const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
                     if (operationTypeNode) {
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
@@ -731,28 +696,31 @@ class NormalizationFactory {
                             parentDefinitionData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                             continue;
                         }
-                        for (const [fieldName, fieldContainer] of parentDefinitionData.fieldDataByFieldName) {
+                        for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByFieldName) {
                             // Arguments can only be fully validated once all parents types are known
-                            this.validateArguments(fieldContainer, `${parentTypeName}.${fieldName}`);
+                            this.validateArguments(fieldData, `${parentTypeName}.${fieldName}`);
                         }
                     }
+                    const newParentTypeName = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION
+                        ? parentDefinitionData.renamedTypeName || parentTypeName
+                        : parentTypeName;
                     const configurationData = {
                         fieldNames: new Set(),
                         isRootNode: isEntity,
-                        typeName: parentTypeName,
+                        typeName: newParentTypeName,
                     };
                     const entityInterfaceData = this.entityInterfaces.get(parentTypeName);
                     if (entityInterfaceData) {
                         entityInterfaceData.concreteTypeNames =
-                            this.abstractToConcreteTypeNames.get(parentTypeName) || new Set();
+                            this.concreteTypeNamesByAbstractTypeName.get(parentTypeName) || new Set();
                         configurationData.isInterfaceObject = entityInterfaceData.isInterfaceObject;
                         configurationData.entityInterfaceConcreteTypeNames = entityInterfaceData.concreteTypeNames;
                     }
-                    const events = this.eventsConfigurations.get(parentTypeName);
+                    const events = this.eventsConfigurations.get(newParentTypeName);
                     if (events) {
                         configurationData.events = events;
                     }
-                    this.configurationDataMap.set(parentTypeName, configurationData);
+                    this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
                     (0, utils_2.addNonExternalFieldsToSet)(parentDefinitionData.fieldDataByFieldName, configurationData.fieldNames);
                     this.validateInterfaceImplementations(parentDefinitionData);
                     definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
@@ -773,10 +741,10 @@ class NormalizationFactory {
         }
         // Check that explicitly defined operations types are valid objects and that their fields are also valid
         for (const operationType of Object.values(graphql_1.OperationTypeNode)) {
-            const node = this.schemaDefinition.operationTypes.get(operationType);
+            const operationTypeNode = this.schemaDefinition.operationTypes.get(operationType);
             const defaultTypeName = (0, utils_3.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType, string_constants_1.OPERATION_TO_DEFAULT);
             // If an operation type name was not declared, use the default
-            const operationTypeName = node ? (0, type_merging_1.getNamedTypeForChild)(`schema.${operationType}`, node.type) : defaultTypeName;
+            const operationTypeName = operationTypeNode ? (0, ast_1.getTypeNodeNamedTypeName)(operationTypeNode.type) : defaultTypeName;
             // If a custom type is used, the default type should not be defined
             if (operationTypeName !== defaultTypeName &&
                 (this.parentDefinitionDataByTypeName.has(defaultTypeName) ||
@@ -784,43 +752,42 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
                 continue;
             }
-            const object = this.parentDefinitionDataByTypeName.get(operationTypeName);
-            const extension = this.parentExtensionDataByTypeName.get(operationTypeName);
-            // Node is truthy if an operation type was explicitly declared
-            if (node) {
+            const objectData = this.parentDefinitionDataByTypeName.get(operationTypeName);
+            const extensionData = this.parentExtensionDataByTypeName.get(operationTypeName);
+            // operationTypeNode is truthy if an operation type was explicitly declared
+            if (operationTypeNode) {
                 // If the type is not defined in the schema, it's always an error
-                if (!object && !extension) {
+                if (!objectData && !extensionData) {
                     this.errors.push((0, errors_1.undefinedTypeError)(operationTypeName));
                     continue;
                 }
                 // Add the explicitly defined type to the map for the federation-factory
-                this.operationTypeNames.set(operationTypeName, operationType);
+                this.operationTypeNodeByTypeName.set(operationTypeName, operationType);
             }
-            if (!object && !extension) {
+            if (!objectData && !extensionData) {
                 continue;
             }
-            const rootNode = this.configurationDataMap.get(operationTypeName);
+            const rootNode = this.configurationDataByParentTypeName.get(defaultTypeName);
             if (rootNode) {
                 rootNode.isRootNode = true;
                 rootNode.typeName = defaultTypeName;
             }
-            const containers = [object, extension];
-            for (const container of containers) {
-                if (!container) {
+            const parentDatas = [objectData, extensionData];
+            for (const parentData of parentDatas) {
+                if (!parentData) {
                     continue;
                 }
-                if (container.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && container.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                    this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, container.kind));
+                if (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                    this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, parentData.kind));
                     continue;
                 }
                 // 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 [fieldName, fieldData] of container.fieldDataByFieldName) {
-                    const fieldPath = `${operationTypeName}.${fieldName}`;
-                    const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldData.node.type);
+                for (const fieldData of parentData.fieldDataByFieldName.values()) {
+                    const fieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldTypeName) &&
                         !this.parentDefinitionDataByTypeName.has(fieldTypeName) &&
-                        !validExtensionOrphans.has(fieldTypeName)) {
+                        !validParentExtensionOrphansByTypeName.has(fieldTypeName)) {
                         this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
                     }
                 }
@@ -837,18 +804,27 @@ class NormalizationFactory {
             }
         }
         for (const [parentTypeName, fieldSetContainers] of this.fieldSetContainerByTypeName) {
-            const parentContainer = this.parentDefinitionDataByTypeName.get(parentTypeName) ||
+            const parentData = 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 &&
-                    parentContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
-                    parentContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION)) {
+            if (!parentData ||
+                (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                    parentData.kind != graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
+                    parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
+                    parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION)) {
                 this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
                 continue;
             }
             // this is where keys, provides, and requires are added to the ConfigurationData
-            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentContainer, fieldSetContainers);
+            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentData, fieldSetContainers);
+        }
+        const persistedDirectiveDefinitionDataByDirectiveName = new Map();
+        for (const directiveDefinitionNode of this.directiveDefinitionByDirectiveName.values()) {
+            // TODO @composeDirective directives would also be handled here
+            const executableLocations = (0, utils_1.extractExecutableDirectiveLocations)(directiveDefinitionNode.locations, new Set());
+            if (executableLocations.size < 1) {
+                continue;
+            }
+            (0, utils_4.addPersistedDirectiveDefinitionDataByNode)(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, executableLocations, this.subgraphName);
         }
         if (this.errors.length > 0) {
             return { errors: this.errors };
@@ -862,15 +838,19 @@ class NormalizationFactory {
                 authorizationDataByParentTypeName: this.authorizationDataByParentTypeName,
                 // configurationDataMap is map of ConfigurationData per type name.
                 // It is an Intermediate configuration object that will be converted to an engine configuration in the router
-                configurationDataMap: this.configurationDataMap,
+                concreteTypeNamesByAbstractTypeName: this.concreteTypeNamesByAbstractTypeName,
+                configurationDataByParentTypeName: this.configurationDataByParentTypeName,
                 entityContainerByTypeName: this.entityContainerByTypeName,
                 entityInterfaces: this.entityInterfaces,
-                parentExtensionDataByTypeName: this.parentExtensionDataByTypeName,
+                parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+                parentExtensionDataByTypeName: validParentExtensionOrphansByTypeName,
                 isVersionTwo: this.isSubgraphVersionTwo,
                 keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
-                operationTypes: this.operationTypeNames,
+                operationTypes: this.operationTypeNodeByTypeName,
+                originalTypeNameByRenamedTypeName: this.originalTypeNameByRenamedTypeName,
                 overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
                 parentDataByTypeName: this.parentDefinitionDataByTypeName,
+                persistedDirectiveDefinitionDataByDirectiveName,
                 subgraphAST: newAST,
                 subgraphString: (0, graphql_1.print)(newAST),
                 schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true }),
@@ -881,6 +861,7 @@ class NormalizationFactory {
 exports.NormalizationFactory = NormalizationFactory;
 function batchNormalize(subgraphs) {
     const authorizationDataByParentTypeName = new Map();
+    const concreteTypeNamesByAbstractTypeName = new Map();
     const entityContainerByTypeName = new Map();
     const internalSubgraphBySubgraphName = new Map();
     const allOverridesByTargetSubgraphName = new Map();
@@ -899,13 +880,14 @@ function batchNormalize(subgraphs) {
             (0, subgraph_1.recordSubgraphName)(subgraph.name, subgraphNames, nonUniqueSubgraphNames);
         }
     }
+    const graph = new graphology_1.MultiGraph();
     for (let i = 0; i < subgraphs.length; i++) {
         const subgraph = subgraphs[i];
         const subgraphName = subgraph.name || `subgraph-${i}-${Date.now()}`;
         if (!subgraph.name) {
             invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
         }
-        const { errors, normalizationResult } = normalizeSubgraph(subgraph.definitions, subgraph.name);
+        const { errors, normalizationResult } = normalizeSubgraph(subgraph.definitions, graph, subgraph.name);
         if (errors) {
             validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, errors));
             continue;
@@ -918,21 +900,30 @@ function batchNormalize(subgraphs) {
         for (const authorizationData of normalizationResult.authorizationDataByParentTypeName.values()) {
             (0, utils_3.upsertAuthorizationData)(authorizationDataByParentTypeName, authorizationData, invalidOrScopesHostPaths);
         }
+        for (const [abstractTypeName, incomingConcreteTypeNames,] of normalizationResult.concreteTypeNamesByAbstractTypeName) {
+            const existingConcreteTypeNames = concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
+            if (!existingConcreteTypeNames) {
+                concreteTypeNamesByAbstractTypeName.set(abstractTypeName, new Set(incomingConcreteTypeNames));
+                continue;
+            }
+            (0, utils_3.addIterableValuesToSet)(incomingConcreteTypeNames, existingConcreteTypeNames);
+        }
         for (const entityContainer of normalizationResult.entityContainerByTypeName.values()) {
             (0, utils_3.upsertEntityContainer)(entityContainerByTypeName, entityContainer);
         }
         if (subgraph.name) {
             internalSubgraphBySubgraphName.set(subgraphName, {
-                configurationDataMap: normalizationResult.configurationDataMap,
+                configurationDataByParentTypeName: normalizationResult.configurationDataByParentTypeName,
                 definitions: normalizationResult.subgraphAST,
                 entityInterfaces: normalizationResult.entityInterfaces,
-                parentExtensionDataByTypeName: normalizationResult.parentExtensionDataByTypeName,
                 keyFieldNamesByParentTypeName: normalizationResult.keyFieldNamesByParentTypeName,
                 isVersionTwo: normalizationResult.isVersionTwo,
                 name: subgraphName,
                 operationTypes: normalizationResult.operationTypes,
                 overriddenFieldNamesByParentTypeName: new Map(),
-                parentDataByTypeName: normalizationResult.parentDataByTypeName,
+                parentDefinitionDataByTypeName: normalizationResult.parentDataByTypeName,
+                parentExtensionDataByTypeName: normalizationResult.parentExtensionDataByTypeName,
+                persistedDirectiveDefinitionDataByDirectiveName: normalizationResult.persistedDirectiveDefinitionDataByDirectiveName,
                 schema: normalizationResult.schema,
                 url: subgraph.url,
             });
@@ -943,8 +934,11 @@ function batchNormalize(subgraphs) {
         for (const [targetSubgraphName, overridesData] of normalizationResult.overridesByTargetSubgraphName) {
             const isTargetValid = subgraphNames.has(targetSubgraphName);
             for (const [parentTypeName, fieldNames] of overridesData) {
+                /* It's possible for a renamed root type to have a field overridden, so make sure any errors at this stage are
+                   propagated with the original typename. */
+                const originalParentTypeName = normalizationResult.originalTypeNameByRenamedTypeName.get(parentTypeName) || parentTypeName;
                 if (!isTargetValid) {
-                    warnings.push((0, warnings_1.invalidOverrideTargetSubgraphNameWarning)(targetSubgraphName, parentTypeName, [...fieldNames]));
+                    warnings.push((0, warnings_1.invalidOverrideTargetSubgraphNameWarning)(targetSubgraphName, originalParentTypeName, [...fieldNames]));
                 }
                 else {
                     const overridesData = (0, utils_3.getValueOrDefault)(allOverridesByTargetSubgraphName, targetSubgraphName, () => new Map());
@@ -952,7 +946,7 @@ function batchNormalize(subgraphs) {
                     (0, utils_3.addIterableValuesToSet)(fieldNames, existingFieldNames);
                 }
                 for (const fieldName of fieldNames) {
-                    const fieldPath = `${parentTypeName}.${fieldName}`;
+                    const fieldPath = `${originalParentTypeName}.${fieldName}`;
                     const sourceSubgraphs = overrideSourceSubgraphNamesByFieldPath.get(fieldPath);
                     if (!sourceSubgraphs) {
                         overrideSourceSubgraphNamesByFieldPath.set(fieldPath, [subgraphName]);
@@ -983,8 +977,10 @@ function batchNormalize(subgraphs) {
     if (allErrors.length > 0) {
         return {
             authorizationDataByParentTypeName,
+            concreteTypeNamesByAbstractTypeName,
             entityContainerByTypeName,
             errors: allErrors,
+            graph,
             internalSubgraphBySubgraphName,
             ...(warnings.length > 0 ? { warnings } : {}),
         };
@@ -993,19 +989,21 @@ function batchNormalize(subgraphs) {
         const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphBySubgraphName, targetSubgraphName, 'internalSubgraphBySubgraphName');
         internalSubgraph.overriddenFieldNamesByParentTypeName = overridesData;
         for (const [parentTypeName, fieldNames] of overridesData) {
-            const configurationData = internalSubgraph.configurationDataMap.get(parentTypeName);
+            const configurationData = internalSubgraph.configurationDataByParentTypeName.get(parentTypeName);
             if (!configurationData) {
                 continue;
             }
             (0, utils_3.subtractSourceSetFromTargetSet)(fieldNames, configurationData.fieldNames);
             if (configurationData.fieldNames.size < 1) {
-                internalSubgraph.configurationDataMap.delete(parentTypeName);
+                internalSubgraph.configurationDataByParentTypeName.delete(parentTypeName);
             }
         }
     }
     return {
         authorizationDataByParentTypeName,
+        concreteTypeNamesByAbstractTypeName,
         entityContainerByTypeName: entityContainerByTypeName,
+        graph,
         internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
         ...(warnings.length > 0 ? { warnings } : {}),
     };