@wundergraph/composition 0.0.1 → 0.3.0

package/dist/normalization/normalization-factory.js

@@ -10,6 +10,7 @@ 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");
 function normalizeSubgraphFromString(subgraph) {
     let document;
     try {
@@ -53,12 +54,30 @@ class NormalizationFactory {
             operationTypes: new Map(),
         };
     }
+    extractArguments(node, map) {
+        if (!node.arguments) {
+            return map;
+        }
+        for (const argumentNode of node.arguments) {
+            const argumentName = argumentNode.name.value;
+            if (map.has(argumentName)) {
+                // TODO
+                this.errors.push(new Error('duplicate argument'));
+                continue;
+            }
+            map.set(argumentName, argumentNode);
+        }
+        return map;
+    }
     extractDirectives(node, map) {
         if (!node.directives) {
             return map;
         }
         for (const directive of node.directives) {
             const directiveName = directive.name.value;
+            if (directiveName === string_constants_1.EXTENDS) {
+                continue;
+            }
             const existingDirectives = map.get(directiveName);
             if (existingDirectives) {
                 existingDirectives.push(directive);
@@ -68,20 +87,6 @@ class NormalizationFactory {
         }
         return map;
     }
-    extractUniqueInterfaces(node, interfaces) {
-        if (!node.interfaces) {
-            return interfaces;
-        }
-        for (const face of node.interfaces) {
-            const name = face.name.value;
-            if (interfaces.has(name)) {
-                this.errors.push(new Error(`Interface "${name}" can only be defined on type "${this.parentTypeName}" once.`)); // TODO
-                continue;
-            }
-            interfaces.add(name);
-        }
-        return interfaces;
-    }
     extractUniqueUnionMembers(members, map) {
         for (const member of members) {
             const name = member.name.value;
@@ -102,7 +107,7 @@ class NormalizationFactory {
                 interfaces.add(interfaceName);
                 continue;
             }
-            this.errors.push((0, errors_1.duplicateInterfaceError)(interfaceName, typeName)); // TODO
+            this.errors.push((0, errors_1.duplicateInterfaceExtensionError)(interfaceName, typeName));
         }
     }
     mergeUniqueUnionMembers(baseUnion, extensionUnion) {
@@ -139,7 +144,7 @@ class NormalizationFactory {
         for (const [directiveName, directives] of parent.directives) {
             const definition = this.allDirectiveDefinitions.get(directiveName);
             if (!definition) {
-                this.errors.push((0, errors_1.undefinedDirectiveError)(parentTypeName, directiveName));
+                this.errors.push((0, errors_1.undefinedDirectiveError)(directiveName, parentTypeName));
                 continue;
             }
             const allArguments = new Set();
@@ -165,7 +170,7 @@ class NormalizationFactory {
                 }
                 if (!directive.arguments || directive.arguments.length < 1) {
                     if (requiredArguments.size > 0) {
-                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, Array.from(requiredArguments)));
+                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, [...requiredArguments]));
                     }
                     else {
                         normalizedDirectives.push(directive);
@@ -173,9 +178,9 @@ class NormalizationFactory {
                     continue;
                 }
                 const definedArguments = (0, utils_2.getDefinedArgumentsForDirective)(directive.arguments, allArguments, directiveName, parentTypeName, errorMessages);
-                const missingRequiredArguments = (0, utils_3.getEntriesNotInSet)(requiredArguments, definedArguments);
+                const missingRequiredArguments = (0, utils_3.getEntriesNotInHashSet)(requiredArguments, definedArguments);
                 if (missingRequiredArguments.length > 0) {
-                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, Array.from(requiredArguments), missingRequiredArguments));
+                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, parentTypeName, [...requiredArguments], missingRequiredArguments));
                 }
                 // Only add unique entity keys
                 if (directiveName === string_constants_1.KEY) {
@@ -198,12 +203,59 @@ class NormalizationFactory {
         }
         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;
+        }
+    }
+    handleObjectLikeExtension(node) {
+        this.isCurrentParentExtension = true;
+        const extension = this.extensions.get(this.parentTypeName);
+        const convertedKind = this.convertKindForExtension(node);
+        if (extension) {
+            if (extension.kind !== convertedKind) {
+                this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
+                return false;
+            }
+            this.extractDirectives(node, extension.directives);
+            (0, utils_1.extractInterfaces)(node, extension.interfaces, this.errors);
+            return;
+        }
+        const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
+        const interfaces = new Set();
+        this.extensions.set(this.parentTypeName, {
+            directives: this.extractDirectives(node, new Map()),
+            fields: new Map(),
+            interfaces: (0, utils_1.extractInterfaces)(node, interfaces, this.errors),
+            isEntity,
+            kind: convertedKind,
+            name: node.name,
+        });
+        if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION
+            || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION
+            || !isEntity) {
+            return;
+        }
+        const existingEntityKeyMap = this.entityMap.get(this.parentTypeName);
+        const { entityKeyMap, errors } = (0, utils_1.getEntityKeyExtractionResults)(node, existingEntityKeyMap || new Map());
+        if (errors.length > 0) {
+            this.errors.push(...errors);
+        }
+        if (!existingEntityKeyMap) {
+            this.entityMap.set(this.parentTypeName, entityKeyMap);
+        }
+    }
     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)(hostPath, directiveName));
+                this.errors.push((0, errors_1.undefinedDirectiveError)(directiveName, hostPath));
                 continue;
             }
             const allArguments = new Set();
@@ -225,14 +277,14 @@ class NormalizationFactory {
                 }
                 if (!directive.arguments || directive.arguments.length < 1) {
                     if (requiredArguments.size > 0) {
-                        errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, Array.from(requiredArguments)));
+                        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.getEntriesNotInSet)(requiredArguments, definedArguments);
+                const missingRequiredArguments = (0, utils_3.getEntriesNotInHashSet)(requiredArguments, definedArguments);
                 if (missingRequiredArguments.length > 0) {
-                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, Array.from(requiredArguments), missingRequiredArguments));
+                    errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, hostPath, [...requiredArguments], missingRequiredArguments));
                 }
             }
             if (errorMessages.length > 0) {
@@ -240,6 +292,85 @@ class NormalizationFactory {
             }
         }
     }
+    validateInterfaceImplementations(container) {
+        if (container.interfaces.size < 1) {
+            return;
+        }
+        const implementationErrorsMap = new Map();
+        for (const interfaceName of container.interfaces) {
+            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parents, interfaceName);
+            if (interfaceContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceContainer.kind);
+            }
+            const implementationErrors = {
+                invalidFieldImplementations: new Map(),
+                unimplementedFields: [],
+            };
+            let hasErrors = false;
+            for (const [fieldName, interfaceField] of interfaceContainer.fields) {
+                let hasNestedErrors = false;
+                const containerField = container.fields.get(fieldName);
+                if (!containerField) {
+                    hasErrors = true;
+                    implementationErrors.unimplementedFields.push(fieldName);
+                    continue;
+                }
+                const invalidFieldImplementation = {
+                    invalidAdditionalArguments: new Set(),
+                    invalidImplementedArguments: [],
+                    originalResponseType: (0, merge_1.printTypeNode)(interfaceField.node.type),
+                    unimplementedArguments: new Set(),
+                };
+                // The implemented field type must be equally or more restrictive than the original interface field type
+                if (!(0, utils_3.isTypeValidImplementation)(interfaceField.node.type, containerField.node.type)) {
+                    hasErrors = true;
+                    hasNestedErrors = true;
+                    invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
+                }
+                const handledArguments = new Set();
+                for (const [argumentName, interfaceArgument] of interfaceField.arguments) {
+                    handledArguments.add(argumentName);
+                    const containerArgument = containerField.arguments.get(argumentName);
+                    // The type implementing the interface must include all arguments with no variation for that argument
+                    if (!containerArgument) {
+                        hasErrors = true;
+                        hasNestedErrors = true;
+                        invalidFieldImplementation.unimplementedArguments.add(argumentName);
+                        continue;
+                    }
+                    // Implemented arguments should be the exact same type
+                    const actualType = (0, merge_1.printTypeNode)(containerArgument.type);
+                    const expectedType = (0, merge_1.printTypeNode)(interfaceArgument.type);
+                    if (expectedType !== actualType) {
+                        hasErrors = true;
+                        hasNestedErrors = true;
+                        invalidFieldImplementation.invalidImplementedArguments.push({ actualType, argumentName, expectedType });
+                    }
+                }
+                // Additional arguments must be optional (nullable)
+                for (const [argumentName, argumentNode] of containerField.arguments) {
+                    if (handledArguments.has(argumentName)) {
+                        continue;
+                    }
+                    if (argumentNode.type.kind !== graphql_1.Kind.NON_NULL_TYPE) {
+                        continue;
+                    }
+                    hasErrors = true;
+                    hasNestedErrors = true;
+                    invalidFieldImplementation.invalidAdditionalArguments.add(argumentName);
+                }
+                if (hasNestedErrors) {
+                    implementationErrors.invalidFieldImplementations.set(fieldName, invalidFieldImplementation);
+                }
+            }
+            if (hasErrors) {
+                implementationErrorsMap.set(interfaceName, implementationErrors);
+            }
+        }
+        if (implementationErrorsMap.size) {
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
+        }
+    }
     normalize(document) {
         const factory = this;
         (0, graphql_1.visit)(document, {
@@ -282,7 +413,7 @@ class NormalizationFactory {
                 enter(node) {
                     const name = node.name.value;
                     if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('enum', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     factory.parentTypeName = name;
@@ -331,7 +462,7 @@ class NormalizationFactory {
                         ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
                         : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
                     if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
-                        throw new Error(''); // TODO
+                        throw (0, errors_1.unexpectedKindFatalError)(name);
                     }
                     if (parent.values.has(name)) {
                         const error = factory.isCurrentParentExtension
@@ -363,7 +494,7 @@ class NormalizationFactory {
                         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 new Error(''); // TODO
+                        throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
                     }
                     if (parent.fields.has(name)) {
                         const error = factory.isCurrentParentExtension
@@ -373,6 +504,7 @@ class NormalizationFactory {
                         return;
                     }
                     parent.fields.set(name, {
+                        arguments: factory.extractArguments(node, new Map),
                         directives: factory.extractDirectives(node, new Map()),
                         name,
                         node,
@@ -386,7 +518,7 @@ class NormalizationFactory {
                 enter(node) {
                     const name = node.name.value;
                     if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('input object', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     factory.parentTypeName = name;
@@ -438,7 +570,7 @@ class NormalizationFactory {
                         ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
                         : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
                     if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
-                        throw new Error(''); // TODO
+                        throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
                     }
                     if (parent.fields.has(name)) {
                         factory.errors.push((0, errors_1.duplicateValueExtensionError)('input', factory.parentTypeName, name));
@@ -454,47 +586,32 @@ class NormalizationFactory {
             InterfaceTypeDefinition: {
                 enter(node) {
                     const name = node.name.value;
+                    factory.parentTypeName = name;
+                    if ((0, utils_1.isNodeExtension)(node)) {
+                        return factory.handleObjectLikeExtension(node);
+                    }
                     if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('interface', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
-                    factory.parentTypeName = name;
                     factory.parents.set(name, {
                         description: node.description,
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
-                        interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
+                        interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
                         kind: node.kind,
                         name: node.name,
                     });
                 },
                 leave() {
+                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
                 },
             },
             InterfaceTypeExtension: {
                 enter(node) {
-                    const name = node.name.value;
-                    factory.parentTypeName = name;
-                    factory.isCurrentParentExtension = true;
-                    const extension = factory.extensions.get(factory.parentTypeName);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectives(node, extension.directives);
-                        factory.extractUniqueInterfaces(node, extension.interfaces);
-                        return;
-                    }
-                    const interfaces = new Set();
-                    factory.extensions.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
-                        fields: new Map(),
-                        interfaces: (0, utils_1.extractInterfaces)(node, interfaces),
-                        kind: node.kind,
-                        name: node.name,
-                    });
+                    factory.parentTypeName = node.name.value;
+                    return factory.handleObjectLikeExtension(node);
                 },
                 leave() {
                     factory.isCurrentParentExtension = false;
@@ -504,20 +621,26 @@ class NormalizationFactory {
             ObjectTypeDefinition: {
                 enter(node) {
                     const name = node.name.value;
+                    factory.parentTypeName = name;
+                    // handling for @extends directive
+                    if ((0, utils_1.isNodeExtension)(node)) {
+                        return factory.handleObjectLikeExtension(node);
+                    }
                     if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('object', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
-                    factory.parentTypeName = name;
+                    const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
                     factory.parents.set(name, {
                         description: node.description,
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
-                        interfaces: factory.extractUniqueInterfaces(node, new Set()),
+                        interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
+                        isEntity,
                         kind: node.kind,
                         name: node.name,
                     });
-                    if (!(0, utils_1.isObjectNodeEntity)(node)) {
+                    if (!isEntity) {
                         return;
                     }
                     const existingEntityKeyMap = factory.entityMap.get(name);
@@ -530,43 +653,14 @@ class NormalizationFactory {
                     }
                 },
                 leave() {
+                    factory.isCurrentParentExtension = false;
                     factory.parentTypeName = '';
                 },
             },
             ObjectTypeExtension: {
                 enter(node) {
-                    const name = node.name.value;
-                    factory.parentTypeName = name;
-                    factory.isCurrentParentExtension = true;
-                    const extension = factory.extensions.get(factory.parentTypeName);
-                    if (extension) {
-                        if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                            factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
-                            return false;
-                        }
-                        factory.extractDirectives(node, extension.directives);
-                        factory.extractUniqueInterfaces(node, extension.interfaces);
-                        return;
-                    }
-                    const interfaces = new Set();
-                    factory.extensions.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
-                        fields: new Map(),
-                        interfaces: (0, utils_1.extractInterfaces)(node, interfaces),
-                        kind: node.kind,
-                        name: node.name,
-                    });
-                    if (!(0, utils_1.isObjectNodeEntity)(node)) {
-                        return;
-                    }
-                    const existingEntityKeyMap = factory.entityMap.get(name);
-                    const { entityKeyMap, errors } = (0, utils_1.getEntityKeyExtractionResults)(node, existingEntityKeyMap || new Map());
-                    if (errors.length > 0) {
-                        factory.errors.push(...errors);
-                    }
-                    if (!existingEntityKeyMap) {
-                        factory.entityMap.set(name, entityKeyMap);
-                    }
+                    factory.parentTypeName = node.name.value;
+                    return factory.handleObjectLikeExtension(node);
                 },
                 leave() {
                     factory.isCurrentParentExtension = false;
@@ -599,7 +693,7 @@ class NormalizationFactory {
                     const name = node.name.value;
                     const parent = factory.parents.get(name);
                     if (parent) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('scalar', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     factory.parents.set(name, {
@@ -633,7 +727,6 @@ class NormalizationFactory {
             },
             SchemaDefinition: {
                 enter(node) {
-                    // Apollo allows multiple schema definitions
                     factory.extractDirectives(node, factory.schemaDefinition.directives);
                     factory.schemaDefinition.description = factory.schemaDefinition.description || node.description;
                 },
@@ -649,7 +742,7 @@ class NormalizationFactory {
                     factory.parentTypeName = name;
                     const parent = factory.parents.get(name);
                     if (parent) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)('union', name));
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     if (!node.types) {
@@ -711,9 +804,23 @@ class NormalizationFactory {
         if (this.schemaDefinition.operationTypes.size > 0) {
             definitions.push((0, utils_2.schemaContainerToNode)(this, this.schemaDefinition));
         }
+        // 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
+        const configurationDataMap = new Map();
         const validExtensionOrphans = new Set();
         const parentsToIgnore = new Set();
         for (const [typeName, extension] of this.extensions) {
+            const entity = this.entityMap.get(typeName);
+            const configurationData = {
+                fieldNames: new Set(),
+                isRootNode: !!entity,
+                selectionSets: entity ? [...entity.keys()] : [],
+                typeName,
+            };
+            if (extension.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                (0, utils_3.addIterableValuesToSet)(extension.fields.keys(), configurationData.fieldNames);
+                configurationDataMap.set(typeName, configurationData);
+            }
             const baseType = this.parents.get(typeName);
             if (!baseType) {
                 if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
@@ -721,14 +828,14 @@ class NormalizationFactory {
                 }
                 else {
                     (0, utils_2.validateEntityKeys)(this, typeName, true);
+                    this.validateInterfaceImplementations(extension);
                     validExtensionOrphans.add(typeName);
                     definitions.push((0, utils_2.objectLikeContainerToNode)(this, extension));
                 }
                 continue;
             }
-            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extension.kind)) {
-                this.errors.push(new Error(`Extension error:\n Incompatible types: ` +
-                    `"${typeName}" is type "${baseType.kind}", but an extension of the same name is type "${extension.kind}.`));
+            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extension.kind, typeName)) {
+                this.errors.push((0, errors_1.incompatibleExtensionError)(typeName, baseType.kind, extension.kind));
                 continue;
             }
             switch (baseType.kind) {
@@ -757,17 +864,20 @@ class NormalizationFactory {
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const objectExtension = extension;
-                    for (const [fieldName, fieldDefinitionNode] of objectExtension.fields) {
-                        if (!baseType.fields.has(fieldName)) {
-                            baseType.fields.set(fieldName, fieldDefinitionNode);
+                    const objectLikeExtension = extension;
+                    for (const [fieldName, fieldContainer] of objectLikeExtension.fields) {
+                        if (baseType.fields.has(fieldName)) {
+                            this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
                             continue;
                         }
-                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
+                        baseType.fields.set(fieldName, fieldContainer);
+                        configurationData.fieldNames.add(fieldName);
                     }
                     (0, utils_2.validateEntityKeys)(this, typeName);
-                    this.mergeUniqueInterfaces(objectExtension.interfaces, baseType.interfaces, typeName);
-                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, baseType, objectExtension));
+                    this.mergeUniqueInterfaces(objectLikeExtension.interfaces, baseType.interfaces, typeName);
+                    this.validateInterfaceImplementations(baseType);
+                    configurationDataMap.set(typeName, configurationData);
+                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, baseType, objectLikeExtension));
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     definitions.push((0, utils_2.scalarContainerToNode)(this, baseType, extension));
@@ -777,7 +887,7 @@ class NormalizationFactory {
                     definitions.push((0, utils_2.unionContainerToNode)(this, baseType, unionExtension));
                     break;
                 default:
-                    throw new Error('Unexpected kind'); // TODO
+                    throw (0, errors_1.unexpectedKindFatalError)(typeName);
             }
             // At this point, the base type has been dealt with, so it doesn't need to be dealt with again
             parentsToIgnore.add(typeName);
@@ -794,9 +904,19 @@ class NormalizationFactory {
                     definitions.push((0, utils_2.inputObjectContainerToNode)(this, parentContainer));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                // Intentional fallthrough
+                // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                    const entity = this.entityMap.get(typeName);
+                    const configurationData = {
+                        fieldNames: new Set(),
+                        isRootNode: !!entity,
+                        selectionSets: entity ? [...entity.keys()] : [],
+                        typeName,
+                    };
+                    (0, utils_3.addIterableValuesToSet)(parentContainer.fields.keys(), configurationData.fieldNames);
                     (0, utils_2.validateEntityKeys)(this, typeName);
+                    this.validateInterfaceImplementations(parentContainer);
+                    configurationDataMap.set(typeName, configurationData);
                     definitions.push((0, utils_2.objectLikeContainerToNode)(this, parentContainer));
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
@@ -823,7 +943,7 @@ class NormalizationFactory {
             }
             const object = this.parents.get(operationTypeName);
             const extension = this.extensions.get(operationTypeName);
-            // Node is truthy of an operation type was explicitly declared
+            // 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
                 if (!object && !extension) {
@@ -833,6 +953,14 @@ class NormalizationFactory {
                 // Add the explicitly defined type to the map for the federation-factory
                 this.operationTypeNames.set(operationTypeName, operationType);
             }
+            if (!object && !extension) {
+                continue;
+            }
+            const rootNode = configurationDataMap.get(operationTypeName);
+            if (rootNode) {
+                rootNode.isRootNode = true;
+                rootNode.typeName = defaultTypeName;
+            }
             const containers = [object, extension];
             for (const container of containers) {
                 if (!container) {
@@ -845,7 +973,8 @@ class NormalizationFactory {
                 // Operations 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 fieldPath = `${operationTypeName}.${fieldContainer.name}`;
+                    const fieldName = fieldContainer.name;
+                    const fieldPath = `${operationTypeName}.${fieldName}`;
                     const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldTypeName) &&
                         !this.parents.has(fieldTypeName) &&
@@ -869,6 +998,7 @@ class NormalizationFactory {
         };
         return {
             normalizationResult: {
+                configurationDataMap,
                 isVersionTwo: this.isSubgraphVersionTwo,
                 operationTypes: this.operationTypeNames,
                 subgraphAST: newAST,