@wundergraph/composition 0.5.2 → 0.6.0

package/dist/normalization/normalization-factory.js

@@ -11,6 +11,7 @@ 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");
 function normalizeSubgraphFromString(subgraph) {
     let document;
     try {
@@ -29,6 +30,7 @@ function normalizeSubgraph(document) {
 }
 exports.normalizeSubgraph = normalizeSubgraph;
 class NormalizationFactory {
+    abstractToConcreteTypeNames = new Map();
     allDirectiveDefinitions = new Map();
     customDirectiveDefinitions = new Map();
     errors = [];
@@ -36,6 +38,7 @@ class NormalizationFactory {
     operationTypeNames = new Map();
     parents = new Map();
     parentTypeName = '';
+    parentsWithChildArguments = new Set();
     extensions = new Map();
     isChild = false;
     isCurrentParentExtension = false;
@@ -54,20 +57,55 @@ class NormalizationFactory {
             operationTypes: new Map(),
         };
     }
-    extractArguments(node, map) {
+    validateInputNamedType(namedType) {
+        if (constants_1.BASE_SCALARS.has(namedType)) {
+            return { hasUnhandledError: false, typeString: '' };
+        }
+        const parentContainer = this.parents.get(namedType);
+        if (!parentContainer) {
+            this.errors.push((0, errors_1.undefinedTypeError)(namedType));
+            return { hasUnhandledError: false, typeString: '' };
+        }
+        switch (parentContainer.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                return { hasUnhandledError: false, typeString: '' };
+            default:
+                return { hasUnhandledError: true, typeString: (0, utils_3.kindToTypeString)(parentContainer.kind) };
+        }
+    }
+    extractArguments(node, argumentByName, fieldPath) {
         if (!node.arguments) {
-            return map;
+            return argumentByName;
         }
+        this.parentsWithChildArguments.add(this.parentTypeName);
+        const duplicatedArguments = new Set();
         for (const argumentNode of node.arguments) {
             const argumentName = argumentNode.name.value;
-            if (map.has(argumentName)) {
-                // TODO
-                this.errors.push(new Error('duplicate argument'));
+            if (argumentByName.has(argumentName)) {
+                duplicatedArguments.add(argumentName);
                 continue;
             }
-            map.set(argumentName, argumentNode);
+            argumentByName.set(argumentName, (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.parentTypeName));
+        }
+        if (duplicatedArguments.size > 0) {
+            this.errors.push((0, errors_1.duplicateArgumentsError)(fieldPath, [...duplicatedArguments]));
+        }
+        return argumentByName;
+    }
+    validateArguments(fieldContainer, fieldPath) {
+        const invalidArguments = [];
+        for (const [argumentName, argumentNode] of fieldContainer.arguments) {
+            const namedType = (0, type_merging_1.getNamedTypeForChild)(fieldPath + `(${argumentName}...)`, argumentNode.type);
+            const { hasUnhandledError, typeString } = this.validateInputNamedType(namedType);
+            if (hasUnhandledError) {
+                invalidArguments.push({ argumentName, namedType, typeString, typeName: (0, merge_1.printTypeNode)(argumentNode.type) });
+            }
+        }
+        if (invalidArguments.length > 0) {
+            this.errors.push((0, errors_1.invalidArgumentsError)(fieldPath, invalidArguments));
         }
-        return map;
     }
     extractDirectives(node, map) {
         if (!node.directives) {
@@ -292,13 +330,45 @@ class NormalizationFactory {
             }
         }
     }
+    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;
+        }
+    }
     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);
+            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parents, 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);
             }
@@ -322,7 +392,7 @@ class NormalizationFactory {
                     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)) {
+                if (!this.isTypeValidImplementation(interfaceField.node.type, containerField.node.type)) {
                     hasErrors = true;
                     hasNestedErrors = true;
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(containerField.node.type);
@@ -373,24 +443,31 @@ 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();
+        let isCurrentParentRootType = false;
         (0, graphql_1.visit)(document, {
             DirectiveDefinition: {
                 enter(node) {
                     const name = node.name.value;
-                    // TODO These sets would potentially allow the user to define these directives more than once
-                    // Add our definitions rather than the existing ones
+                    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;
                     }
-                    const directiveDefinition = factory.allDirectiveDefinitions.get(name);
-                    if (directiveDefinition) {
-                        factory.errors.push((0, errors_1.duplicateDirectiveDefinitionError)(name));
-                        return false;
-                    }
                     factory.allDirectiveDefinitions.set(name, node);
                     factory.customDirectiveDefinitions.set(name, node);
                     return false;
@@ -418,7 +495,7 @@ class NormalizationFactory {
                     }
                     factory.parentTypeName = name;
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         kind: node.kind,
                         name: node.name,
@@ -459,8 +536,8 @@ class NormalizationFactory {
                 enter(node) {
                     const name = node.name.value;
                     const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parents, 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);
                     }
@@ -474,13 +551,16 @@ class NormalizationFactory {
                     parent.values.set(name, {
                         directives: factory.extractDirectives(node, new Map()),
                         name,
-                        node,
+                        node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
                     });
                 },
             },
             FieldDefinition: {
                 enter(node) {
                     const name = node.name.value;
+                    if (isCurrentParentRootType && (name === string_constants_1.SERVICE_FIELD || name === string_constants_1.ENTITIES_FIELD)) {
+                        return false;
+                    }
                     const fieldPath = `${factory.parentTypeName}.${name}`;
                     factory.isChild = true;
                     const fieldRootType = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
@@ -488,8 +568,8 @@ class NormalizationFactory {
                         factory.referencedTypeNames.add(fieldRootType);
                     }
                     const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parents, 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 &&
@@ -503,11 +583,18 @@ class NormalizationFactory {
                         factory.errors.push(error);
                         return;
                     }
+                    // recreate the node so the argument descriptions are updated
                     parent.fields.set(name, {
-                        arguments: factory.extractArguments(node, new Map),
+                        arguments: factory.extractArguments(node, new Map(), fieldPath),
                         directives: factory.extractDirectives(node, new Map()),
                         name,
-                        node,
+                        node: {
+                            ...node,
+                            arguments: node.arguments?.map((arg) => ({
+                                ...arg,
+                                description: (0, utils_1.formatDescription)(arg.description),
+                            })),
+                        }
                     });
                 },
                 leave() {
@@ -523,7 +610,7 @@ class NormalizationFactory {
                     }
                     factory.parentTypeName = name;
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
                         kind: node.kind,
@@ -566,9 +653,13 @@ class NormalizationFactory {
                         return;
                     }
                     const name = node.name.value;
+                    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.extensions, factory.parentTypeName)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName);
+                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parents, 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);
                     }
@@ -579,7 +670,7 @@ class NormalizationFactory {
                     parent.fields.set(name, {
                         directives: factory.extractDirectives(node, new Map()),
                         name,
-                        node,
+                        node: { ...node, description: (0, utils_1.formatDescription)(node.description) },
                     });
                 },
             },
@@ -595,7 +686,7 @@ class NormalizationFactory {
                         return false;
                     }
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
                         interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
@@ -621,7 +712,12 @@ class NormalizationFactory {
             ObjectTypeDefinition: {
                 enter(node) {
                     const name = node.name.value;
+                    if (name === string_constants_1.SERVICE) {
+                        return false;
+                    }
+                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name);
                     factory.parentTypeName = name;
+                    (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
                     // handling for @extends directive
                     if ((0, utils_1.isNodeExtension)(node)) {
                         return factory.handleObjectLikeExtension(node);
@@ -632,7 +728,7 @@ class NormalizationFactory {
                     }
                     const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
                         interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
@@ -654,16 +750,24 @@ class NormalizationFactory {
                 },
                 leave() {
                     factory.isCurrentParentExtension = false;
+                    isCurrentParentRootType = false;
                     factory.parentTypeName = '';
                 },
             },
             ObjectTypeExtension: {
                 enter(node) {
-                    factory.parentTypeName = node.name.value;
+                    const name = node.name.value;
+                    if (name === string_constants_1.SERVICE) {
+                        return false;
+                    }
+                    isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name);
+                    factory.parentTypeName = name;
+                    (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
                     return factory.handleObjectLikeExtension(node);
                 },
                 leave() {
                     factory.isCurrentParentExtension = false;
+                    isCurrentParentRootType = false;
                     factory.parentTypeName = '';
                 },
             },
@@ -697,7 +801,7 @@ class NormalizationFactory {
                         return false;
                     }
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
                         name: node.name,
@@ -728,7 +832,7 @@ class NormalizationFactory {
             SchemaDefinition: {
                 enter(node) {
                     factory.extractDirectives(node, factory.schemaDefinition.directives);
-                    factory.schemaDefinition.description = factory.schemaDefinition.description || node.description;
+                    factory.schemaDefinition.description = node.description;
                 },
             },
             SchemaExtension: {
@@ -749,8 +853,9 @@ class NormalizationFactory {
                         factory.errors.push((0, errors_1.noDefinedUnionMembersError)(name));
                         return false;
                     }
+                    (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
                     factory.parents.set(name, {
-                        description: node.description,
+                        description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         kind: node.kind,
                         name: node.name,
@@ -769,6 +874,7 @@ class NormalizationFactory {
                         factory.errors.push();
                         return false;
                     }
+                    (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));
@@ -809,91 +915,107 @@ class NormalizationFactory {
         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);
+        for (const [extensionTypeName, extensionContainer] of this.extensions) {
+            const entity = this.entityMap.get(extensionTypeName);
             const configurationData = {
                 fieldNames: new Set(),
                 isRootNode: !!entity,
-                selectionSets: entity ? [...entity.keys()] : [],
-                typeName,
+                typeName: extensionTypeName,
             };
-            if (extension.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                (0, utils_3.addIterableValuesToSet)(extension.fields.keys(), configurationData.fieldNames);
-                configurationDataMap.set(typeName, configurationData);
+            if (entity) {
+                configurationData.keys = [...entity.keys()].map((selectionSet) => ({
+                    fieldName: '', selectionSet,
+                }));
+            }
+            if (extensionContainer.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);
+                }
+                (0, utils_3.addIterableValuesToSet)(extensionContainer.fields.keys(), configurationData.fieldNames);
+                configurationDataMap.set(extensionTypeName, configurationData);
             }
-            const baseType = this.parents.get(typeName);
+            const baseType = this.parents.get(extensionTypeName);
             if (!baseType) {
-                if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                    this.errors.push((0, errors_1.noBaseTypeExtensionError)(typeName));
+                if (extensionContainer.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                    this.errors.push((0, errors_1.noBaseTypeExtensionError)(extensionTypeName));
                 }
                 else {
-                    (0, utils_2.validateEntityKeys)(this, typeName, true);
-                    this.validateInterfaceImplementations(extension);
-                    validExtensionOrphans.add(typeName);
-                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, extension));
+                    (0, utils_2.validateEntityKeys)(this, extensionTypeName, true);
+                    this.validateInterfaceImplementations(extensionContainer);
+                    validExtensionOrphans.add(extensionTypeName);
+                    definitions.push((0, utils_2.objectLikeContainerToNode)(this, extensionContainer));
                 }
                 continue;
             }
-            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extension.kind, typeName)) {
-                this.errors.push((0, errors_1.incompatibleExtensionError)(typeName, baseType.kind, extension.kind));
+            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(baseType.kind, extensionContainer.kind, extensionTypeName)) {
+                this.errors.push((0, errors_1.incompatibleExtensionError)(extensionTypeName, baseType.kind, extensionContainer.kind));
                 continue;
             }
             switch (baseType.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    const enumExtension = extension;
+                    const enumExtension = extensionContainer;
                     for (const [valueName, enumValueDefinitionNode] of enumExtension.values) {
                         if (!baseType.values.has(valueName)) {
                             baseType.values.set(valueName, enumValueDefinitionNode);
                             continue;
                         }
-                        this.errors.push((0, errors_1.duplicateEnumValueDefinitionError)(valueName, typeName));
+                        this.errors.push((0, errors_1.duplicateEnumValueDefinitionError)(valueName, extensionTypeName));
                     }
                     definitions.push((0, utils_2.enumContainerToNode)(this, baseType, enumExtension));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    const inputExtension = extension;
+                    const inputExtension = extensionContainer;
                     for (const [fieldName, inputValueDefinitionNode] of inputExtension.fields) {
                         if (!baseType.fields.has(fieldName)) {
                             baseType.fields.set(fieldName, inputValueDefinitionNode);
                             continue;
                         }
-                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
+                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
                     }
                     definitions.push((0, utils_2.inputObjectContainerToNode)(this, baseType, inputExtension));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const objectLikeExtension = extension;
+                    const objectLikeExtension = extensionContainer;
+                    if (this.operationTypeNames.has(extensionTypeName)) {
+                        objectLikeExtension.fields.delete(string_constants_1.SERVICE_FIELD);
+                        objectLikeExtension.fields.delete(string_constants_1.ENTITIES_FIELD);
+                    }
                     for (const [fieldName, fieldContainer] of objectLikeExtension.fields) {
+                        if (fieldContainer.arguments.size > 0) {
+                            // Arguments can only be fully validated once all parents types are known
+                            this.validateArguments(fieldContainer, `${extensionTypeName}.${fieldName}`);
+                        }
                         if (baseType.fields.has(fieldName)) {
-                            this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, typeName));
+                            this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
                             continue;
                         }
                         baseType.fields.set(fieldName, fieldContainer);
                         configurationData.fieldNames.add(fieldName);
                     }
-                    (0, utils_2.validateEntityKeys)(this, typeName);
-                    this.mergeUniqueInterfaces(objectLikeExtension.interfaces, baseType.interfaces, typeName);
+                    (0, utils_2.validateEntityKeys)(this, extensionTypeName);
+                    this.mergeUniqueInterfaces(objectLikeExtension.interfaces, baseType.interfaces, extensionTypeName);
                     this.validateInterfaceImplementations(baseType);
-                    configurationDataMap.set(typeName, configurationData);
+                    configurationDataMap.set(extensionTypeName, 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));
+                    definitions.push((0, utils_2.scalarContainerToNode)(this, baseType, extensionContainer));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    const unionExtension = extension;
+                    const unionExtension = extensionContainer;
                     definitions.push((0, utils_2.unionContainerToNode)(this, baseType, unionExtension));
                     break;
                 default:
-                    throw (0, errors_1.unexpectedKindFatalError)(typeName);
+                    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(typeName);
+            parentsToIgnore.add(extensionTypeName);
         }
-        for (const [typeName, parentContainer] of this.parents) {
-            if (parentsToIgnore.has(typeName)) {
+        for (const [parentTypeName, parentContainer] of this.parents) {
+            if (parentsToIgnore.has(parentTypeName)) {
                 continue;
             }
             switch (parentContainer.kind) {
@@ -906,17 +1028,36 @@ class NormalizationFactory {
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const entity = this.entityMap.get(typeName);
+                    const entity = this.entityMap.get(parentTypeName);
+                    if (this.operationTypeNames.has(parentTypeName)) {
+                        parentContainer.fields.delete(string_constants_1.SERVICE_FIELD);
+                        parentContainer.fields.delete(string_constants_1.ENTITIES_FIELD);
+                    }
+                    if (this.parentsWithChildArguments.has(parentTypeName)) {
+                        const parentContainer = (0, utils_3.getOrThrowError)(this.parents, parentTypeName, string_constants_1.PARENTS);
+                        if (parentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION
+                            && parentContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                            continue;
+                        }
+                        for (const [fieldName, fieldContainer] of parentContainer.fields) {
+                            // Arguments can only be fully validated once all parents types are known
+                            this.validateArguments(fieldContainer, `${parentTypeName}.${fieldName}`);
+                        }
+                    }
                     const configurationData = {
                         fieldNames: new Set(),
                         isRootNode: !!entity,
-                        selectionSets: entity ? [...entity.keys()] : [],
-                        typeName,
+                        typeName: parentTypeName,
                     };
+                    if (entity) {
+                        configurationData.keys = [...entity.keys()].map((selectionSet) => ({
+                            fieldName: '', selectionSet,
+                        }));
+                    }
                     (0, utils_3.addIterableValuesToSet)(parentContainer.fields.keys(), configurationData.fieldNames);
-                    (0, utils_2.validateEntityKeys)(this, typeName);
+                    (0, utils_2.validateEntityKeys)(this, parentTypeName);
                     this.validateInterfaceImplementations(parentContainer);
-                    configurationDataMap.set(typeName, configurationData);
+                    configurationDataMap.set(parentTypeName, configurationData);
                     definitions.push((0, utils_2.objectLikeContainerToNode)(this, parentContainer));
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
@@ -926,15 +1067,16 @@ class NormalizationFactory {
                     definitions.push((0, utils_2.unionContainerToNode)(this, parentContainer));
                     break;
                 default:
-                    throw (0, errors_1.unexpectedKindFatalError)(typeName);
+                    throw (0, errors_1.unexpectedKindFatalError)(parentTypeName);
             }
         }
         // 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 defaultTypeName = (0, utils_3.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, 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 = 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.parents.has(defaultTypeName) || this.extensions.has(defaultTypeName))) {
@@ -970,7 +1112,7 @@ class NormalizationFactory {
                     this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, container.kind));
                     continue;
                 }
-                // Operations whose response type is an extension orphan could be valid through a federated graph
+                // 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;
@@ -985,7 +1127,11 @@ class NormalizationFactory {
             }
         }
         for (const referencedTypeName of this.referencedTypeNames) {
-            if (!this.parents.has(referencedTypeName) && !this.entityMap.has(referencedTypeName)) {
+            if (this.parents.has(referencedTypeName) || this.entityMap.has(referencedTypeName)) {
+                continue;
+            }
+            const extension = this.extensions.get(referencedTypeName);
+            if (!extension || extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }