@wundergraph/composition 0.28.4 → 0.28.5

package/dist/normalization/normalization-factory.js

@@ -16,6 +16,7 @@ const merge_1 = require("@graphql-tools/merge");
 const subgraph_1 = require("../subgraph/subgraph");
 const warnings_1 = require("../warnings/warnings");
 const walkers_1 = require("./walkers");
+const type_definition_data_1 = require("../schema-building/type-definition-data");
 const utils_4 = require("../schema-building/utils");
 const ast_1 = require("../schema-building/ast");
 const graph_1 = require("../resolvability-graph/graph");
@@ -61,7 +62,6 @@ class NormalizationFactory {
     operationTypeNodeByTypeName = new Map();
     originalTypeNameByRenamedTypeName = new Map();
     parentDefinitionDataByTypeName = new Map();
-    parentExtensionDataByTypeName = new Map();
     originalParentTypeName = '';
     parentsWithChildArguments = new Set();
     overridesByTargetSubgraphName = new Map();
@@ -264,54 +264,332 @@ class NormalizationFactory {
         }
         return directivesByDirectiveName;
     }
-    mergeUniqueInterfaces(extensionInterfaces, interfaces, typeName) {
-        for (const interfaceName of extensionInterfaces) {
-            if (!interfaces.has(interfaceName)) {
-                interfaces.add(interfaceName);
+    isTypeNameRootType(typeName) {
+        return string_constants_1.ROOT_TYPE_NAMES.has(typeName) || this.operationTypeNodeByTypeName.has(typeName);
+    }
+    extractDirectives(node, directivesByDirectiveName, hostPath, isArgument = false) {
+        if (!node.directives) {
+            return directivesByDirectiveName;
+        }
+        const entityKeys = new Set();
+        for (const directiveNode of node.directives) {
+            const errorMessages = (0, utils_4.getDirectiveValidationErrors)(directiveNode, node.kind, directivesByDirectiveName, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, hostPath, isArgument);
+            const directiveName = directiveNode.name.value;
+            if (errorMessages.length > 0) {
+                this.errors.push((0, errors_1.invalidDirectiveError)(directiveName, hostPath, errorMessages));
+                continue;
+            }
+            if (string_constants_1.IGNORED_PARENT_DIRECTIVES.has(directiveName)) {
+                continue;
+            }
+            if (directiveName === string_constants_1.KEY) {
+                // The argument was validated earlier
+                const entityKey = directiveNode.arguments[0].value.value;
+                if (entityKeys.has(entityKey)) {
+                    continue;
+                }
+                entityKeys.add(entityKey);
+            }
+            const existingDirectives = directivesByDirectiveName.get(directiveName);
+            existingDirectives
+                ? existingDirectives.push(directiveNode)
+                : directivesByDirectiveName.set(directiveName, [directiveNode]);
+        }
+        return directivesByDirectiveName;
+    }
+    /* ExtensionType uses a trichotomy rather than a boolean because @extends is still a definition.
+     * A definition and another definition with @extends would still be an error, so it cannot be treated
+     * as a regular extension.
+     * V1 definitions with @extends need a base type.
+     */
+    getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType = false) {
+        // If the extend keyword is present, it's simply an extension
+        if (isRealExtension) {
+            return type_definition_data_1.ExtensionType.REAL;
+        }
+        /*
+         * @extends is not interpreted as an extension under the following circumstances:
+         * 1. It's a root type
+         * 2. It's a V2 subgraph
+         * 3. And (of course) if @extends isn't defined at all
+         */
+        if (isRootType || this.isSubgraphVersionTwo || !directivesByDirectiveName.has(string_constants_1.EXTENDS)) {
+            return type_definition_data_1.ExtensionType.NONE;
+        }
+        // If it's a V1 subgraph and defines @extends, it is considered an extension across subgraphs
+        return type_definition_data_1.ExtensionType.EXTENDS;
+    }
+    setParentDataExtensionType(parentData, incomingExtensionType) {
+        switch (parentData.extensionType) {
+            case type_definition_data_1.ExtensionType.EXTENDS:
+            // intentional fallthrough
+            case type_definition_data_1.ExtensionType.NONE: {
+                if (incomingExtensionType === type_definition_data_1.ExtensionType.REAL) {
+                    return;
+                }
+                this.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(parentData.kind), parentData.name));
+                return;
+            }
+            default: {
+                parentData.extensionType = incomingExtensionType;
+            }
+        }
+    }
+    extractImplementedInterfaceTypeNames(node, implementedInterfaceTypeNames) {
+        if (!node.interfaces) {
+            return implementedInterfaceTypeNames;
+        }
+        const parentTypeName = node.name.value;
+        for (const implementedInterface of node.interfaces) {
+            const interfaceTypeName = implementedInterface.name.value;
+            if (implementedInterfaceTypeNames.has(interfaceTypeName)) {
+                this.errors.push((0, errors_1.duplicateImplementedInterfaceError)((0, utils_3.kindToConvertedTypeString)(node.kind), parentTypeName, interfaceTypeName));
                 continue;
             }
-            this.errors.push((0, errors_1.duplicateInterfaceExtensionError)(interfaceName, typeName));
+            implementedInterfaceTypeNames.add(interfaceTypeName);
+        }
+        return implementedInterfaceTypeNames;
+    }
+    updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType) {
+        this.setParentDataExtensionType(parentData, extensionType);
+        this.extractImplementedInterfaceTypeNames(node, parentData.implementedInterfaceTypeNames);
+        parentData.isEntity ||= directivesByDirectiveName.has(string_constants_1.KEY);
+        parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+        parentData.subgraphNames.add(this.subgraphName);
+        parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+    }
+    addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames, concreteTypeName) {
+        for (const interfaceName of interfaceTypeNames) {
+            (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, interfaceName, () => new Set()).add(concreteTypeName);
+            this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(interfaceName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(concreteTypeName), concreteTypeName, true);
+        }
+    }
+    upsertInterfaceDataByNode(node, isRealExtension = false) {
+        const typeName = node.name.value;
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const entityInterfaceData = this.entityInterfaceDataByTypeName.get(typeName);
+        if (entityInterfaceData && node.fields) {
+            for (const fieldNode of node.fields) {
+                entityInterfaceData.interfaceFieldNames.add(fieldNode.name.value);
+            }
+        }
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
+            }
+            this.updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType);
+            return;
+        }
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            directivesByDirectiveName,
+            extensionType,
+            fieldDataByFieldName: new Map(),
+            implementedInterfaceTypeNames: this.extractImplementedInterfaceTypeNames(node, new Set()),
+            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
+            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+            name: typeName,
+            node: (0, ast_1.getMutableInterfaceNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            subgraphNames: new Set([this.subgraphName]),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
+        });
+    }
+    getRenamedRootTypeName(typeName) {
+        const operationTypeNode = this.operationTypeNodeByTypeName.get(typeName);
+        if (!operationTypeNode) {
+            return typeName;
+        }
+        switch (operationTypeNode) {
+            case graphql_1.OperationTypeNode.MUTATION:
+                return string_constants_1.MUTATION;
+            case graphql_1.OperationTypeNode.SUBSCRIPTION:
+                return string_constants_1.SUBSCRIPTION;
+            default:
+                return string_constants_1.QUERY;
         }
     }
-    handleInterfaceObject(node) {
-        if (!(0, utils_1.isNodeInterfaceObject)(node)) {
+    addInterfaceObjectFieldsByNode(node) {
+        const typeName = node.name.value;
+        const entityInterfaceData = this.entityInterfaceDataByTypeName.get(typeName);
+        if (!entityInterfaceData || !entityInterfaceData.isInterfaceObject || !node.fields) {
             return;
         }
+        for (const fieldNode of node.fields) {
+            entityInterfaceData.interfaceObjectFieldNames.add(fieldNode.name.value);
+        }
+    }
+    upsertObjectDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
-        if (this.entityInterfaceDataByTypeName.has(typeName)) {
-            // TODO error
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const isRootType = this.isTypeNameRootType(typeName);
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType);
+        this.addInterfaceObjectFieldsByNode(node);
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
+            }
+            this.updateCompositeOutputDataByNode(node, parentData, directivesByDirectiveName, extensionType);
+            this.addConcreteTypeNamesForImplementedInterfaces(parentData.implementedInterfaceTypeNames, typeName);
             return;
         }
-        this.entityInterfaceDataByTypeName.set(typeName, {
-            fieldDatas: [],
-            interfaceObjectFieldNames: new Set(node.fields?.map((field) => field.name.value)),
-            interfaceFieldNames: new Set(),
-            isInterfaceObject: true,
-            typeName,
+        const implementedInterfaceTypeNames = this.extractImplementedInterfaceTypeNames(node, new Set());
+        this.addConcreteTypeNamesForImplementedInterfaces(implementedInterfaceTypeNames, typeName);
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            directivesByDirectiveName,
+            extensionType,
+            fieldDataByFieldName: new Map(),
+            implementedInterfaceTypeNames,
+            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
+            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isRootType,
+            kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+            name: typeName,
+            node: (0, ast_1.getMutableObjectNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            renamedTypeName: this.getRenamedRootTypeName(typeName),
+            subgraphNames: new Set([this.subgraphName]),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
         });
     }
-    handleExtensionWithFields(node, isRootType = false) {
-        this.isCurrentParentExtension = true;
-        const parentExtensionData = this.parentExtensionDataByTypeName.get(this.originalParentTypeName);
-        const convertedKind = (0, utils_4.convertKindForExtension)(node);
-        if (parentExtensionData) {
-            if (parentExtensionData.kind !== convertedKind) {
-                this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, parentExtensionData.kind));
-                return false;
+    upsertEnumDataByNode(node, isRealExtension = false) {
+        const typeName = node.name.value;
+        this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectivesAndAuthorization(node, parentData?.directivesByDirectiveName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
+            }
+            this.setParentDataExtensionType(parentData, extensionType);
+            parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            return;
+        }
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            appearances: 1,
+            directivesByDirectiveName,
+            extensionType,
+            enumValueDataByValueName: new Map(),
+            kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
+            name: typeName,
+            node: (0, ast_1.getMutableEnumNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
+        });
+    }
+    upsertInputObjectByNode(node, isRealExtension = false) {
+        const typeName = node.name.value;
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
             }
-            (0, utils_4.extractDirectives)(node, parentExtensionData.directivesByDirectiveName, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, this.originalParentTypeName);
-            (0, utils_1.extractInterfaces)(node, parentExtensionData.implementedInterfaceTypeNames, this.errors);
+            this.setParentDataExtensionType(parentData, extensionType);
+            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+            parentData.subgraphNames.add(this.subgraphName);
+            parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             return;
         }
-        const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-        (0, utils_4.addExtensionWithFieldsDataByNode)(this.parentExtensionDataByTypeName, node, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, isEntity, isRootType, this.subgraphName, this.renamedParentTypeName);
-        const entityInterfaceData = this.entityInterfaceDataByTypeName.get(this.renamedParentTypeName);
-        if (!entityInterfaceData) {
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            directivesByDirectiveName,
+            extensionType,
+            inputValueDataByValueName: new Map(),
+            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+            name: typeName,
+            node: (0, ast_1.getMutableInputObjectNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            subgraphNames: new Set([this.subgraphName]),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
+        });
+    }
+    upsertScalarByNode(node, isRealExtension = false) {
+        const typeName = node.name.value;
+        this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectivesAndAuthorization(node, parentData?.directivesByDirectiveName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
+            }
+            this.setParentDataExtensionType(parentData, extensionType);
+            parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             return;
         }
-        for (const fieldNode of node.fields || []) {
-            entityInterfaceData.interfaceFieldNames.add(fieldNode.name.value);
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            directivesByDirectiveName,
+            extensionType,
+            kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
+            name: typeName,
+            node: (0, ast_1.getMutableScalarNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
+        });
+    }
+    extractUnionMembers(node, membersByMemberTypeName) {
+        if (!node.types) {
+            return membersByMemberTypeName;
         }
+        const unionTypeName = node.name.value;
+        for (const member of node.types) {
+            const memberTypeName = member.name.value;
+            if (membersByMemberTypeName.has(memberTypeName)) {
+                this.errors.push((0, errors_1.duplicateUnionMemberDefinitionError)(unionTypeName, memberTypeName));
+                continue;
+            }
+            (0, utils_3.getValueOrDefault)(this.concreteTypeNamesByAbstractTypeName, unionTypeName, () => new Set()).add(memberTypeName);
+            /*
+             * Scalars are never valid Union member types.
+             * However, base scalars are not upserted to the type definition data.
+             * Consequently, reference checks would yield unknown type errors in addition to invalid member errors.
+             * This check prevents error doubling were a Union member a base Scalar.
+             * */
+            if (!constants_1.BASE_SCALARS.has(memberTypeName)) {
+                this.referencedTypeNames.add(memberTypeName);
+            }
+            membersByMemberTypeName.set(memberTypeName, member);
+        }
+        return membersByMemberTypeName;
+    }
+    upsertUnionByNode(node, isRealExtension = false) {
+        const typeName = node.name.value;
+        const parentData = this.parentDefinitionDataByTypeName.get(typeName);
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map(), typeName);
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        // Also adds the concrete type name edges to the internal graph
+        this.addConcreteTypeNamesForUnion(node);
+        if (parentData) {
+            if (parentData.kind !== graphql_1.Kind.UNION_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_3.kindToTypeString)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
+                return;
+            }
+            this.setParentDataExtensionType(parentData, extensionType);
+            this.extractUnionMembers(node, parentData.memberByMemberTypeName);
+            parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
+            return;
+        }
+        this.parentDefinitionDataByTypeName.set(typeName, {
+            directivesByDirectiveName,
+            extensionType,
+            kind: graphql_1.Kind.UNION_TYPE_DEFINITION,
+            memberByMemberTypeName: this.extractUnionMembers(node, new Map()),
+            name: typeName,
+            node: (0, ast_1.getMutableUnionNode)(node.name),
+            persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
+        });
     }
     extractKeyFieldSets(node, keyFieldSetData) {
         const isUnresolvableByRawKeyFieldSet = keyFieldSetData.isUnresolvableByKeyFieldSet;
@@ -871,23 +1149,6 @@ class NormalizationFactory {
         const nonKeyFieldNameByFieldPath = new Map();
         const nonEntityExtensionTypeNames = new Set();
         const invalidObjectTypeNames = new Set();
-        for (const [typeName, data] of this.parentExtensionDataByTypeName) {
-            if (data.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                continue;
-            }
-            // If a required events directive is returned, the parent type is a root type
-            if (data.isRootType) {
-                this.validateEventDrivenRootType(data, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath);
-                continue;
-            }
-            const keyFieldNames = this.keyFieldNamesByParentTypeName.get(typeName);
-            if (!keyFieldNames || !data.isEntity) {
-                nonEntityExtensionTypeNames.add(typeName);
-                continue;
-            }
-            this.validateEventDrivenKeyDefinition(typeName, invalidKeyFieldSetsByEntityTypeName);
-            this.validateEventDrivenObjectFields(data.fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath);
-        }
         for (const [typeName, data] of this.parentDefinitionDataByTypeName) {
             // validate edfs__PublishResult and edfs__NatsStreamConfiguration separately
             if (typeName === string_constants_1.EDFS_PUBLISH_RESULT || typeName === string_constants_1.EDFS_NATS_STREAM_CONFIGURATION) {
@@ -949,14 +1210,18 @@ class NormalizationFactory {
         }
     }
     validateUnionMembers(data) {
+        if (data.memberByMemberTypeName.size < 1) {
+            this.errors.push((0, errors_1.noDefinedUnionMembersError)(data.name));
+            return;
+        }
         const invalidMembers = [];
         for (const memberName of data.memberByMemberTypeName.keys()) {
-            const memberData = this.parentDefinitionDataByTypeName.get(memberName) || this.parentExtensionDataByTypeName.get(memberName);
+            const memberData = this.parentDefinitionDataByTypeName.get(memberName);
             // Invalid references are propagated as an error elsewhere
             if (!memberData) {
                 continue;
             }
-            if (memberData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && memberData.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            if (memberData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                 invalidMembers.push(`"${memberName}", which is type "${(0, utils_3.kindToTypeString)(memberData.kind)}"`);
             }
         }
@@ -975,7 +1240,7 @@ class NormalizationFactory {
             this.internalGraph.addEdge(this.internalGraph.addOrUpdateNode(interfaceName, { isAbstract: true }), this.internalGraph.addOrUpdateNode(concreteTypeName), concreteTypeName, true);
         }
     }
-    addConcreteTypesForUnion(node) {
+    addConcreteTypeNamesForUnion(node) {
         if (!node.types || node.types.length < 1) {
             return;
         }
@@ -995,13 +1260,9 @@ class NormalizationFactory {
     }
     validateAndAddKeysToConfiguration() {
         for (const [parentTypeName, keyFieldSetData] of this.keyFieldSetDataByTypeName) {
-            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName) ||
-                this.parentExtensionDataByTypeName.get(parentTypeName);
+            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName);
             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)) {
+                (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
                 this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
                 continue;
             }
@@ -1081,133 +1342,20 @@ class NormalizationFactory {
         if (this.schemaDefinition.operationTypes.size > 0) {
             definitions.push((0, utils_4.getSchemaNodeByData)(this.schemaDefinition, this.errors, this.directiveDefinitionByDirectiveName));
         }
-        const validParentExtensionOrphansByTypeName = new Map();
-        const handledParentTypeNames = new Set();
-        for (const [extensionTypeName, parentExtensionData] of this.parentExtensionDataByTypeName) {
-            const isEntity = this.entityDataByTypeName.has(extensionTypeName);
-            const newParentTypeName = parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION
-                ? parentExtensionData.renamedTypeName || extensionTypeName
-                : extensionTypeName;
-            const configurationData = {
-                fieldNames: new Set(),
-                isRootNode: isEntity,
-                typeName: newParentTypeName,
-            };
-            this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
-            if (parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                if (this.operationTypeNodeByTypeName.has(extensionTypeName)) {
-                    configurationData.isRootNode = true;
-                    parentExtensionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
-                    parentExtensionData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
-                }
-                (0, utils_2.addFieldNamesToConfigurationData)(parentExtensionData.fieldDataByFieldName, configurationData);
-            }
-            const parentDefinitionData = this.parentDefinitionDataByTypeName.get(extensionTypeName);
-            if (!parentDefinitionData) {
-                if (parentExtensionData.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                    this.errors.push((0, errors_1.noBaseTypeExtensionError)(extensionTypeName));
-                }
-                else {
-                    this.validateInterfaceImplementations(parentExtensionData);
-                    validParentExtensionOrphansByTypeName.set(extensionTypeName, parentExtensionData);
-                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentExtensionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
-                }
-                continue;
-            }
-            if (!(0, utils_1.areBaseAndExtensionKindsCompatible)(parentDefinitionData.kind, parentExtensionData.kind, extensionTypeName)) {
-                this.errors.push((0, errors_1.incompatibleExtensionError)(extensionTypeName, parentDefinitionData.kind, parentExtensionData.kind));
-                continue;
-            }
-            switch (parentDefinitionData.kind) {
-                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    const enumExtensionData = parentExtensionData;
-                    for (const [valueName, enumValueDefinitionNode] of enumExtensionData.enumValueDataByValueName) {
-                        if (!parentDefinitionData.enumValueDataByValueName.has(valueName)) {
-                            parentDefinitionData.enumValueDataByValueName.set(valueName, enumValueDefinitionNode);
-                            continue;
-                        }
-                        this.errors.push((0, errors_1.duplicateEnumValueDefinitionError)(valueName, extensionTypeName));
-                    }
-                    definitions.push((0, utils_4.getEnumNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, enumExtensionData));
-                    break;
-                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    const inputObjectExtensionData = parentExtensionData;
-                    for (const [fieldName, inputValueDefinitionNode] of inputObjectExtensionData.inputValueDataByValueName) {
-                        if (!parentDefinitionData.inputValueDataByValueName.has(fieldName)) {
-                            parentDefinitionData.inputValueDataByValueName.set(fieldName, inputValueDefinitionNode);
-                            continue;
-                        }
-                        this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
-                    }
-                    definitions.push((0, utils_4.getInputObjectNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, inputObjectExtensionData));
-                    break;
-                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                // intentional fallthrough
-                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const extensionWithFieldsData = parentExtensionData;
-                    const operationTypeNode = this.operationTypeNodeByTypeName.get(extensionTypeName);
-                    const isObject = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION;
-                    const externalInterfaceFieldNames = [];
-                    if (operationTypeNode) {
-                        configurationData.isRootNode = true;
-                        extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
-                        extensionWithFieldsData.fieldDataByFieldName.delete(string_constants_1.ENTITIES_FIELD);
-                    }
-                    for (const [fieldName, fieldData] of extensionWithFieldsData.fieldDataByFieldName) {
-                        if (!isObject && fieldData.isExternalBySubgraphName.get(this.subgraphName)) {
-                            externalInterfaceFieldNames.push(fieldName);
-                        }
-                        if (fieldData.argumentDataByArgumentName.size > 0) {
-                            // Arguments can only be fully validated once all parents types are known
-                            this.validateArguments(fieldData, `${extensionTypeName}.${fieldName}`);
-                        }
-                        if (parentDefinitionData.fieldDataByFieldName.has(fieldName)) {
-                            this.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, extensionTypeName));
-                            continue;
-                        }
-                        parentDefinitionData.fieldDataByFieldName.set(fieldName, fieldData);
-                        if (!fieldData.argumentDataByArgumentName.has(string_constants_1.EXTERNAL)) {
-                            configurationData.fieldNames.add(fieldName);
-                        }
-                    }
-                    this.mergeUniqueInterfaces(extensionWithFieldsData.implementedInterfaceTypeNames, parentDefinitionData.implementedInterfaceTypeNames, extensionTypeName);
-                    this.validateInterfaceImplementations(parentDefinitionData);
-                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName, extensionWithFieldsData));
-                    if (externalInterfaceFieldNames.length > 0) {
-                        this.isSubgraphVersionTwo
-                            ? this.errors.push((0, errors_1.externalInterfaceFieldsError)(extensionTypeName, externalInterfaceFieldNames))
-                            : this.warnings.push((0, warnings_1.externalInterfaceFieldsWarning)(this.subgraphName, extensionTypeName, externalInterfaceFieldNames));
-                    }
-                    // Interfaces and objects must define at least one field
-                    if (parentDefinitionData.fieldDataByFieldName.size < 1 &&
-                        !(0, utils_2.isNodeQuery)(extensionTypeName, operationTypeNode)) {
-                        this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), extensionTypeName));
-                    }
-                    // Add the base type field names to the configuration data
-                    (0, utils_2.addFieldNamesToConfigurationData)(parentDefinitionData.fieldDataByFieldName, configurationData);
-                    break;
-                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions.push((0, utils_4.getScalarNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, parentExtensionData));
-                    break;
-                case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    definitions.push((0, utils_4.getUnionNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, parentExtensionData));
-                    this.validateUnionMembers(parentDefinitionData);
-                    break;
-                default:
-                    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
-            handledParentTypeNames.add(extensionTypeName);
-        }
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
-            if (handledParentTypeNames.has(parentTypeName)) {
-                continue;
-            }
             switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    if (parentDefinitionData.enumValueDataByValueName.size < 1) {
+                        this.errors.push((0, errors_1.noDefinedEnumValuesError)(parentTypeName));
+                        break;
+                    }
                     definitions.push((0, utils_4.getEnumNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    if (parentDefinitionData.inputValueDataByValueName.size < 1) {
+                        this.errors.push((0, errors_1.noInputValueDefinitionsError)(parentTypeName));
+                        break;
+                    }
                     definitions.push((0, utils_4.getInputObjectNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
@@ -1258,13 +1406,17 @@ class NormalizationFactory {
                     this.configurationDataByParentTypeName.set(newParentTypeName, configurationData);
                     (0, utils_2.addFieldNamesToConfigurationData)(parentDefinitionData.fieldDataByFieldName, configurationData);
                     this.validateInterfaceImplementations(parentDefinitionData);
-                    definitions.push((0, utils_4.getParentWithFieldsNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
+                    definitions.push((0, utils_4.getCompositeOutputNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName, this.authorizationDataByParentTypeName));
                     // interfaces and objects must define at least one field
                     if (parentDefinitionData.fieldDataByFieldName.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
                         this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
                     }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                    if (parentDefinitionData.extensionType === type_definition_data_1.ExtensionType.REAL) {
+                        this.errors.push((0, errors_1.noBaseScalarDefinitionError)(parentTypeName));
+                        break;
+                    }
                     definitions.push((0, utils_4.getScalarNodeByData)(parentDefinitionData, this.errors, this.directiveDefinitionByDirectiveName));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
@@ -1282,25 +1434,22 @@ class NormalizationFactory {
             // If an operation type name was not declared, use the default
             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) ||
-                    this.parentExtensionDataByTypeName.has(defaultTypeName))) {
+            if (operationTypeName !== defaultTypeName && this.parentDefinitionDataByTypeName.has(defaultTypeName)) {
                 this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
                 continue;
             }
             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 (!objectData && !extensionData) {
+                if (!objectData) {
                     this.errors.push((0, errors_1.undefinedTypeError)(operationTypeName));
                     continue;
                 }
                 // Add the explicitly defined type to the map for the federation-factory
                 this.operationTypeNodeByTypeName.set(operationTypeName, operationType);
             }
-            if (!objectData && !extensionData) {
+            if (!objectData) {
                 continue;
             }
             const rootNode = this.configurationDataByParentTypeName.get(defaultTypeName);
@@ -1308,46 +1457,28 @@ class NormalizationFactory {
                 rootNode.isRootNode = true;
                 rootNode.typeName = defaultTypeName;
             }
-            const parentDatas = [objectData, extensionData];
-            for (const parentData of parentDatas) {
-                if (!parentData) {
-                    continue;
-                }
-                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 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) &&
-                        !validParentExtensionOrphansByTypeName.has(fieldTypeName)) {
-                        this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
-                    }
+            if (objectData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, objectData.kind));
+                continue;
+            }
+            for (const fieldData of objectData.fieldDataByFieldName.values()) {
+                const fieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+                if (!constants_1.BASE_SCALARS.has(fieldTypeName) && !this.parentDefinitionDataByTypeName.has(fieldTypeName)) {
+                    this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
                 }
             }
         }
         for (const referencedTypeName of this.referencedTypeNames) {
-            if (this.parentDefinitionDataByTypeName.has(referencedTypeName) ||
-                this.entityDataByTypeName.has(referencedTypeName)) {
-                continue;
-            }
-            const extension = this.parentExtensionDataByTypeName.get(referencedTypeName);
-            if (!extension || extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            if (!this.parentDefinitionDataByTypeName.has(referencedTypeName) &&
+                !this.entityDataByTypeName.has(referencedTypeName)) {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }
         this.validateAndAddKeysToConfiguration();
         for (const [parentTypeName, fieldSetData] of this.fieldSetDataByTypeName) {
-            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName) ||
-                this.parentExtensionDataByTypeName.get(parentTypeName);
+            const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName);
             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)) {
+                (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && parentData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
                 this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
                 continue;
             }
@@ -1391,7 +1522,6 @@ class NormalizationFactory {
                 originalTypeNameByRenamedTypeName: this.originalTypeNameByRenamedTypeName,
                 overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
                 parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
-                parentExtensionDataByTypeName: validParentExtensionOrphansByTypeName,
                 persistedDirectiveDefinitionDataByDirectiveName,
                 subgraphAST: newAST,
                 subgraphString: (0, graphql_1.print)(newAST),
@@ -1469,7 +1599,6 @@ function batchNormalize(subgraphs) {
                 operationTypes: normalizationResult.operationTypes,
                 overriddenFieldNamesByParentTypeName: new Map(),
                 parentDefinitionDataByTypeName: normalizationResult.parentDefinitionDataByTypeName,
-                parentExtensionDataByTypeName: normalizationResult.parentExtensionDataByTypeName,
                 persistedDirectiveDefinitionDataByDirectiveName: normalizationResult.persistedDirectiveDefinitionDataByDirectiveName,
                 schema: normalizationResult.schema,
                 url: subgraph.url,