@wundergraph/composition 0.48.3 → 0.48.5

package/dist/v1/normalization/normalization-factory.js

@@ -88,7 +88,7 @@ class NormalizationFactory {
         this.internalGraph = internalGraph;
         this.internalGraph.setSubgraphName(this.subgraphName);
         this.schemaData = {
-            directivesByDirectiveName: new Map(),
+            directivesByName: new Map(),
             kind: graphql_1.Kind.SCHEMA_DEFINITION,
             name: string_constants_1.SCHEMA,
             operationTypes: new Map(),
@@ -188,7 +188,7 @@ class NormalizationFactory {
                             if (!enumValue) {
                                 return false;
                             }
-                            return !enumValue.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+                            return !enumValue.directivesByName.has(string_constants_1.INACCESSIBLE);
                         }
                         if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
                             return false;
@@ -203,32 +203,32 @@ class NormalizationFactory {
             }
         }
     }
-    handleFieldInheritableDirectives({ directivesByDirectiveName, fieldName, inheritedDirectiveNames, parentData, }) {
-        if (this.doesParentRequireFetchReasons && !directivesByDirectiveName.has(string_constants_1.REQUIRE_FETCH_REASONS)) {
-            directivesByDirectiveName.set(string_constants_1.REQUIRE_FETCH_REASONS, [(0, utils_5.generateSimpleDirective)(string_constants_1.REQUIRE_FETCH_REASONS)]);
+    handleFieldInheritableDirectives({ directivesByName, fieldName, inheritedDirectiveNames, parentData, }) {
+        if (this.doesParentRequireFetchReasons && !directivesByName.has(string_constants_1.REQUIRE_FETCH_REASONS)) {
+            directivesByName.set(string_constants_1.REQUIRE_FETCH_REASONS, [(0, utils_5.generateSimpleDirective)(string_constants_1.REQUIRE_FETCH_REASONS)]);
             inheritedDirectiveNames.add(string_constants_1.REQUIRE_FETCH_REASONS);
         }
-        if (this.doesParentRequireFetchReasons || directivesByDirectiveName.has(string_constants_1.REQUIRE_FETCH_REASONS)) {
+        if (this.doesParentRequireFetchReasons || directivesByName.has(string_constants_1.REQUIRE_FETCH_REASONS)) {
             parentData.requireFetchReasonsFieldNames.add(fieldName);
         }
         if (!(0, utils_3.isObjectDefinitionData)(parentData)) {
             return;
         }
-        if (this.isParentObjectExternal && !directivesByDirectiveName.has(string_constants_1.EXTERNAL)) {
-            directivesByDirectiveName.set(string_constants_1.EXTERNAL, [(0, utils_5.generateSimpleDirective)(string_constants_1.EXTERNAL)]);
+        if (this.isParentObjectExternal && !directivesByName.has(string_constants_1.EXTERNAL)) {
+            directivesByName.set(string_constants_1.EXTERNAL, [(0, utils_5.generateSimpleDirective)(string_constants_1.EXTERNAL)]);
             inheritedDirectiveNames.add(string_constants_1.EXTERNAL);
         }
-        if (directivesByDirectiveName.has(string_constants_1.EXTERNAL)) {
+        if (directivesByName.has(string_constants_1.EXTERNAL)) {
             this.unvalidatedExternalFieldCoords.add(`${parentData.name}.${fieldName}`);
         }
-        if (this.isParentObjectShareable && !directivesByDirectiveName.has(string_constants_1.SHAREABLE)) {
-            directivesByDirectiveName.set(string_constants_1.SHAREABLE, [(0, utils_5.generateSimpleDirective)(string_constants_1.SHAREABLE)]);
+        if (this.isParentObjectShareable && !directivesByName.has(string_constants_1.SHAREABLE)) {
+            directivesByName.set(string_constants_1.SHAREABLE, [(0, utils_5.generateSimpleDirective)(string_constants_1.SHAREABLE)]);
             inheritedDirectiveNames.add(string_constants_1.SHAREABLE);
         }
     }
-    extractDirectives(node, directivesByDirectiveName) {
+    extractDirectives(node, directivesByName) {
         if (!node.directives) {
-            return directivesByDirectiveName;
+            return directivesByName;
         }
         const isCompositeKind = (0, utils_3.isCompositeOutputNodeKind)(node.kind);
         const isObjectKind = (0, utils_3.isObjectNodeKind)(node.kind);
@@ -236,10 +236,10 @@ class NormalizationFactory {
             const directiveName = directiveNode.name.value;
             // Don't create pointless repetitions of @shareable
             if (directiveName === string_constants_1.SHAREABLE) {
-                (0, utils_5.getValueOrDefault)(directivesByDirectiveName, directiveName, () => [directiveNode]);
+                (0, utils_5.getValueOrDefault)(directivesByName, directiveName, () => [directiveNode]);
             }
             else {
-                (0, utils_5.getValueOrDefault)(directivesByDirectiveName, directiveName, () => []).push(directiveNode);
+                (0, utils_5.getValueOrDefault)(directivesByName, directiveName, () => []).push(directiveNode);
             }
             if (!isCompositeKind) {
                 continue;
@@ -251,7 +251,7 @@ class NormalizationFactory {
             this.isParentObjectExternal ||= directiveName === string_constants_1.EXTERNAL;
             this.isParentObjectShareable ||= directiveName === string_constants_1.SHAREABLE;
         }
-        return directivesByDirectiveName;
+        return directivesByName;
     }
     validateDirective({ data, definitionData, directiveCoords, directiveNode, errorMessages, requiredArgumentNames, }) {
         const directiveName = directiveNode.name.value;
@@ -360,7 +360,7 @@ class NormalizationFactory {
     }
     validateDirectives(data, directiveCoords) {
         const undefinedDirectiveNames = new Set();
-        for (const [directiveName, directiveNodes] of data.directivesByDirectiveName) {
+        for (const [directiveName, directiveNodes] of data.directivesByName) {
             const definitionData = this.directiveDefinitionDataByName.get(directiveName);
             if (!definitionData) {
                 if (!undefinedDirectiveNames.has(directiveName)) {
@@ -432,7 +432,7 @@ class NormalizationFactory {
      * as a regular extension.
      * V1 definitions with @extends need a base type.
      */
-    getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType = false) {
+    getNodeExtensionType(isRealExtension, directivesByName, isRootType = false) {
         // If the extend keyword is present, it's simply an extension
         if (isRealExtension) {
             return types_1.ExtensionType.REAL;
@@ -443,7 +443,7 @@ class NormalizationFactory {
          * 2. It's a V2 subgraph (but extends is temporarily propagated to handle @external key fields)
          * 3. And (of course) if @extends isn't defined at all
          */
-        if (isRootType || !directivesByDirectiveName.has(string_constants_1.EXTENDS)) {
+        if (isRootType || !directivesByName.has(string_constants_1.EXTENDS)) {
             return types_1.ExtensionType.NONE;
         }
         // If a V1 non-root Object defines @extends, it is considered an extension across subgraphs.
@@ -507,12 +507,12 @@ class NormalizationFactory {
         data.configureDescriptionDataBySubgraphName.set(this.subgraphName, configureDescriptionData);
     }
     extractConfigureDescriptionsData(data) {
-        const configureDescriptionNodes = data.directivesByDirectiveName.get(string_constants_1.CONFIGURE_DESCRIPTION);
+        const configureDescriptionNodes = data.directivesByName.get(string_constants_1.CONFIGURE_DESCRIPTION);
         if (configureDescriptionNodes && configureDescriptionNodes.length == 1) {
             this.extractConfigureDescriptionData(data, configureDescriptionNodes[0]);
         }
         // TODO configureChildDescriptions will be added in another PR
-        // const configureChildDescriptionsNodes = data.directivesByDirectiveName.get(CONFIGURE_CHILD_DESCRIPTIONS);
+        // const configureChildDescriptionsNodes = data.directivesByName.get(CONFIGURE_CHILD_DESCRIPTIONS);
         // if (configureChildDescriptionsNodes && configureChildDescriptionsNodes.length == 1) {
         // }
     }
@@ -536,8 +536,8 @@ class NormalizationFactory {
         this.extractImplementedInterfaceTypeNames(node, data.implementedInterfaceTypeNames);
         data.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
         this.extractConfigureDescriptionsData(data);
-        data.isEntity ||= data.directivesByDirectiveName.has(string_constants_1.KEY);
-        data.isInaccessible ||= data.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+        data.isEntity ||= data.directivesByName.has(string_constants_1.KEY);
+        data.isInaccessible ||= data.directivesByName.has(string_constants_1.INACCESSIBLE);
         data.subgraphNames.add(this.subgraphName);
     }
     addConcreteTypeNamesForImplementedInterfaces(interfaceTypeNames, concreteTypeName) {
@@ -690,11 +690,11 @@ class NormalizationFactory {
         }
         return true;
     }
-    addFieldDataByNode(fieldDataByFieldName, node, argumentDataByArgumentName, directivesByDirectiveName, inheritedDirectiveNames = new Set()) {
+    addFieldDataByNode(fieldDataByFieldName, node, argumentDataByArgumentName, directivesByName, inheritedDirectiveNames = new Set()) {
         const name = node.name.value;
         const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
         const fieldCoords = `${this.originalParentTypeName}.${name}`;
-        const { isExternal, isShareable } = (0, utils_4.isNodeExternalOrShareable)(node, !this.isSubgraphVersionTwo, directivesByDirectiveName);
+        const { isExternal, isShareable } = (0, utils_4.isNodeExternalOrShareable)(node, !this.isSubgraphVersionTwo, directivesByName);
         const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(node.type);
         const fieldData = {
             argumentDataByName: argumentDataByArgumentName,
@@ -704,7 +704,7 @@ class NormalizationFactory {
             ]),
             federatedCoords: `${parentTypeName}.${name}`,
             inheritedDirectiveNames,
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isInaccessible: directivesByName.has(string_constants_1.INACCESSIBLE),
             isShareableBySubgraphName: new Map([[this.subgraphName, isShareable]]),
             kind: graphql_1.Kind.FIELD_DEFINITION,
             name,
@@ -717,7 +717,7 @@ class NormalizationFactory {
             renamedParentTypeName: parentTypeName,
             subgraphNames: new Set([this.subgraphName]),
             type: (0, ast_1.getMutableTypeNode)(node.type, fieldCoords, this.errors),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             description: (0, utils_1.formatDescription)(node.description),
         };
         if (!constants_1.BASE_SCALARS.has(fieldData.namedTypeName)) {
@@ -743,7 +743,7 @@ class NormalizationFactory {
         const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(node.type);
         const inputValueData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName: this.extractDirectives(node, new Map()),
+            directivesByName: this.extractDirectives(node, new Map()),
             federatedCoords,
             fieldName,
             includeDefaultValue: !!node.defaultValue,
@@ -769,8 +769,8 @@ class NormalizationFactory {
     upsertInterfaceDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         const entityInterfaceData = this.entityInterfaceDataByTypeName.get(typeName);
         if (entityInterfaceData && node.fields) {
             for (const fieldNode of node.fields) {
@@ -787,12 +787,12 @@ class NormalizationFactory {
         }
         const newParentData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             fieldDataByName: new Map(),
             implementedInterfaceTypeNames: this.extractImplementedInterfaceTypeNames(node, new Set()),
-            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isEntity: directivesByName.has(string_constants_1.KEY),
+            isInaccessible: directivesByName.has(string_constants_1.INACCESSIBLE),
             kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInterfaceNode)(node.name),
@@ -831,9 +831,9 @@ class NormalizationFactory {
     upsertObjectDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName ?? new Map());
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName ?? new Map());
         const isRootType = this.isTypeNameRootType(typeName);
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType);
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName, isRootType);
         this.addInterfaceObjectFieldsByNode(node);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
@@ -841,23 +841,23 @@ class NormalizationFactory {
                 return;
             }
             this.updateCompositeOutputDataByNode(node, parentData, extensionType);
-            if (!directivesByDirectiveName.has(string_constants_1.INTERFACE_OBJECT)) {
+            if (!directivesByName.has(string_constants_1.INTERFACE_OBJECT)) {
                 this.addConcreteTypeNamesForImplementedInterfaces(parentData.implementedInterfaceTypeNames, typeName);
             }
             return;
         }
         const implementedInterfaceTypeNames = this.extractImplementedInterfaceTypeNames(node, new Set());
-        if (!directivesByDirectiveName.has(string_constants_1.INTERFACE_OBJECT)) {
+        if (!directivesByName.has(string_constants_1.INTERFACE_OBJECT)) {
             this.addConcreteTypeNamesForImplementedInterfaces(implementedInterfaceTypeNames, typeName);
         }
         const newParentData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             fieldDataByName: new Map(),
             implementedInterfaceTypeNames,
-            isEntity: directivesByDirectiveName.has(string_constants_1.KEY),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isEntity: directivesByName.has(string_constants_1.KEY),
+            isInaccessible: directivesByName.has(string_constants_1.INACCESSIBLE),
             isRootType,
             kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
             name: typeName,
@@ -875,15 +875,15 @@ class NormalizationFactory {
         const typeName = node.name.value;
         this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION) {
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToNodeType)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
-            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+            parentData.isInaccessible ||= directivesByName.has(string_constants_1.INACCESSIBLE);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             this.extractConfigureDescriptionsData(parentData);
@@ -892,10 +892,10 @@ class NormalizationFactory {
         const newParentData = {
             appearances: 1,
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             enumValueDataByName: new Map(),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isInaccessible: directivesByName.has(string_constants_1.INACCESSIBLE),
             kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableEnumNode)(node.name),
@@ -909,8 +909,8 @@ class NormalizationFactory {
     upsertInputObjectByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToNodeType)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
@@ -919,7 +919,7 @@ class NormalizationFactory {
                 };
             }
             this.setParentDataExtensionType(parentData, extensionType);
-            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+            parentData.isInaccessible ||= directivesByName.has(string_constants_1.INACCESSIBLE);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             this.extractConfigureDescriptionsData(parentData);
@@ -930,10 +930,10 @@ class NormalizationFactory {
         }
         const newParentData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             inputValueDataByName: new Map(),
-            isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
+            isInaccessible: directivesByName.has(string_constants_1.INACCESSIBLE),
             kind: graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableInputObjectNode)(node.name),
@@ -952,8 +952,8 @@ class NormalizationFactory {
         const typeName = node.name.value;
         this.internalGraph.addOrUpdateNode(typeName, { isLeaf: true });
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         if (parentData) {
             if (parentData.kind !== graphql_1.Kind.SCALAR_TYPE_DEFINITION) {
                 this.errors.push((0, errors_1.multipleNamedTypeDefinitionError)(typeName, (0, utils_5.kindToNodeType)(parentData.kind), (0, utils_3.kindToConvertedTypeString)(node.kind)));
@@ -967,7 +967,7 @@ class NormalizationFactory {
         }
         const newParentData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
             name: typeName,
@@ -1007,8 +1007,8 @@ class NormalizationFactory {
     upsertUnionByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
-        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName);
+        const directivesByName = this.extractDirectives(node, parentData?.directivesByName || new Map());
+        const extensionType = this.getNodeExtensionType(isRealExtension, directivesByName);
         // Also adds the concrete type name edges to the internal graph
         this.addConcreteTypeNamesForUnion(node);
         if (parentData) {
@@ -1025,7 +1025,7 @@ class NormalizationFactory {
         }
         const newParentData = {
             configureDescriptionDataBySubgraphName: new Map(),
-            directivesByDirectiveName,
+            directivesByName: directivesByName,
             extensionType,
             kind: graphql_1.Kind.UNION_TYPE_DEFINITION,
             memberByMemberTypeName: this.extractUnionMembers(node, new Map()),
@@ -1106,20 +1106,51 @@ class NormalizationFactory {
         }
         const fieldData = (0, utils_5.getOrThrowError)(parentData.fieldDataByName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
         const fieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+        const fieldCoords = `${parentTypeName}.${fieldName}`;
+        if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
+            return {
+                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)({
+                    fieldCoords,
+                    responseType: fieldNamedTypeName,
+                    subgraphName: this.subgraphName,
+                }),
+            };
+        }
         const namedTypeData = this.parentDefinitionDataByTypeName.get(fieldNamedTypeName);
         // This error should never happen
         if (!namedTypeData) {
             return {
-                errorString: (0, errors_1.unknownNamedTypeErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+                errorString: (0, errors_1.unknownNamedTypeErrorMessage)(fieldCoords, fieldNamedTypeName),
             };
         }
+        // @TODO handle abstract types and fragments
         if (namedTypeData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION && namedTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
             return {
-                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)({
+                    fieldCoords,
+                    responseType: fieldNamedTypeName,
+                    subgraphName: this.subgraphName,
+                }),
             };
         }
         return { fieldSetParentData: namedTypeData };
     }
+    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, }) {
+        if (this.isSubgraphVersionTwo) {
+            this.errors.push((0, errors_1.nonExternalConditionalFieldError)({
+                directiveCoords,
+                directiveName,
+                fieldSet,
+                subgraphName: this.subgraphName,
+                targetCoords: currentFieldCoords,
+            }));
+            return;
+        }
+        /* In V1, @requires and @provides do not need to declare any part of the field set @external.
+         * It would appear that any such non-external fields are treated as if they are non-conditionally provided.
+         * */
+        this.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, this.subgraphName, currentFieldCoords, fieldSet, directiveName));
+    }
     validateConditionalFieldSet(selectionSetParentData, fieldSet, directiveFieldName, isProvides, directiveParentTypeName) {
         // Create a new selection set so that the value can be parsed as a new DocumentNode
         const { error, documentNode } = (0, utils_1.safeParse)('{' + fieldSet + '}');
@@ -1164,6 +1195,21 @@ class NormalizationFactory {
                     fieldCoordsPath.push(currentFieldCoords);
                     fieldPath.push(fieldName);
                     lastFieldName = fieldName;
+                    if (fieldName === string_constants_1.TYPENAME) {
+                        if (isProvides) {
+                            errorMessages.push((0, errors_1.typeNameAlreadyProvidedErrorMessage)(currentFieldCoords, nf.subgraphName));
+                            return graphql_1.BREAK;
+                        }
+                        if (externalAncestors.size < 1) {
+                            nf.#handleNonExternalConditionalField({
+                                currentFieldCoords,
+                                directiveCoords,
+                                directiveName,
+                                fieldSet,
+                            });
+                        }
+                        return;
+                    }
                     const fieldData = parentData.fieldDataByName.get(fieldName);
                     // undefined if the field does not exist on the parent
                     if (!fieldData) {
@@ -1188,14 +1234,12 @@ class NormalizationFactory {
                         namedTypeData?.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
                         namedTypeData?.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
                         if (externalAncestors.size < 1 && !isDefinedExternal) {
-                            if (nf.isSubgraphVersionTwo) {
-                                nf.errors.push((0, errors_1.nonExternalConditionalFieldError)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
-                                return;
-                            }
-                            /* In V1, @requires and @provides do not need to declare any part of the field set @external.
-                             * It would appear that any such non-external fields are treated as if they are non-conditionally provided.
-                             * */
-                            nf.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
+                            nf.#handleNonExternalConditionalField({
+                                currentFieldCoords,
+                                directiveCoords,
+                                directiveName,
+                                fieldSet,
+                            });
                             return;
                         }
                         if (externalAncestors.size < 1 && isUnconditionallyProvided) {
@@ -1315,6 +1359,10 @@ class NormalizationFactory {
                             errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName));
                             return graphql_1.BREAK;
                         }
+                        if (lastFieldName === string_constants_1.TYPENAME) {
+                            errorMessages.push((0, errors_1.invalidSelectionSetDefinitionErrorMessage)(fieldSet, fieldCoordsPath, string_constants_1.STRING_SCALAR, (0, utils_5.kindToNodeType)(graphql_1.Kind.SCALAR_TYPE_DEFINITION)));
+                            return graphql_1.BREAK;
+                        }
                         const fieldData = parentData.fieldDataByName.get(lastFieldName);
                         if (!fieldData) {
                             errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentData.name, lastFieldName));
@@ -1404,7 +1452,7 @@ class NormalizationFactory {
         if (data.implementedInterfaceTypeNames.size < 1) {
             return;
         }
-        const isParentInaccessible = data.directivesByDirectiveName.has(string_constants_1.INACCESSIBLE);
+        const isParentInaccessible = data.directivesByName.has(string_constants_1.INACCESSIBLE);
         const implementationErrorsMap = new Map();
         const invalidImplementationTypeStringByTypeName = new Map();
         let doesInterfaceImplementItself = false;
@@ -2006,7 +2054,7 @@ class NormalizationFactory {
             const fieldCoords = `${fieldData.originalParentTypeName}.${fieldName}`;
             const definedEventsDirectiveNames = new Set();
             for (const eventsDirectiveName of strings_1.EVENT_DIRECTIVE_NAMES) {
-                if (fieldData.directivesByDirectiveName.has(eventsDirectiveName)) {
+                if (fieldData.directivesByName.has(eventsDirectiveName)) {
                     definedEventsDirectiveNames.add(eventsDirectiveName);
                 }
             }
@@ -2265,9 +2313,9 @@ class NormalizationFactory {
             }
         }
     }
-    getValidFlattenedDirectiveArray(directivesByDirectiveName, directiveCoords, removeInheritedDirectives = false) {
+    getValidFlattenedDirectiveArray(directivesByName, directiveCoords, removeInheritedDirectives = false) {
         const flattenedArray = [];
-        for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
+        for (const [directiveName, directiveNodes] of directivesByName) {
             if (removeInheritedDirectives && string_constants_1.INHERITABLE_DIRECTIVE_NAMES.has(directiveName)) {
                 continue;
             }
@@ -2305,62 +2353,67 @@ class NormalizationFactory {
                 flattenedArray.push(keyDirectiveNode);
                 normalizedDirectiveNodes.push(keyDirectiveNode);
             }
-            directivesByDirectiveName.set(directiveName, normalizedDirectiveNodes);
+            directivesByName.set(directiveName, normalizedDirectiveNodes);
         }
         return flattenedArray;
     }
     getEnumNodeByData(enumDefinitionData) {
         enumDefinitionData.node.description = enumDefinitionData.description;
-        enumDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(enumDefinitionData.directivesByDirectiveName, enumDefinitionData.name);
+        enumDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(enumDefinitionData.directivesByName, enumDefinitionData.name);
         enumDefinitionData.node.values = (0, utils_4.childMapToValueArray)(enumDefinitionData.enumValueDataByName);
         return enumDefinitionData.node;
     }
     getInputObjectNodeByData(inputObjectDefinitionData) {
         inputObjectDefinitionData.node.description = inputObjectDefinitionData.description;
-        inputObjectDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(inputObjectDefinitionData.directivesByDirectiveName, inputObjectDefinitionData.name);
+        inputObjectDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(inputObjectDefinitionData.directivesByName, inputObjectDefinitionData.name);
         inputObjectDefinitionData.node.fields = (0, utils_4.childMapToValueArray)(inputObjectDefinitionData.inputValueDataByName);
         return inputObjectDefinitionData.node;
     }
     getCompositeOutputNodeByData(compositeOutputData) {
         compositeOutputData.node.description = compositeOutputData.description;
-        compositeOutputData.node.directives = this.getValidFlattenedDirectiveArray(compositeOutputData.directivesByDirectiveName, compositeOutputData.name, true);
+        compositeOutputData.node.directives = this.getValidFlattenedDirectiveArray(compositeOutputData.directivesByName, compositeOutputData.name, true);
         compositeOutputData.node.fields = (0, utils_4.childMapToValueArray)(compositeOutputData.fieldDataByName);
         compositeOutputData.node.interfaces = (0, utils_1.setToNamedTypeNodeArray)(compositeOutputData.implementedInterfaceTypeNames);
         return compositeOutputData.node;
     }
     getScalarNodeByData(scalarDefinitionData) {
         scalarDefinitionData.node.description = scalarDefinitionData.description;
-        scalarDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByDirectiveName, scalarDefinitionData.name);
+        scalarDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByName, scalarDefinitionData.name);
         return scalarDefinitionData.node;
     }
     getSchemaNodeByData(schemaData) {
         const operationTypes = [];
-        for (const operationTypeNode of Object.values(graphql_1.OperationTypeNode)) {
-            const node = schemaData.operationTypes.get(operationTypeNode);
-            if (node) {
-                operationTypes.push(node);
-                continue;
-            }
-            const defaultRootTypeName = (0, utils_5.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationTypeNode, 'operationTypeNodeToDefaultType');
-            if (!this.parentDefinitionDataByTypeName.has(defaultRootTypeName)) {
+        for (const [operation, { type: { name: { value }, }, },] of schemaData.operationTypes) {
+            const data = this.parentDefinitionDataByTypeName.get(value);
+            if (!data || !(0, utils_3.isObjectDefinitionData)(data)) {
                 continue;
             }
             operationTypes.push({
                 kind: graphql_1.Kind.OPERATION_TYPE_DEFINITION,
-                operation: operationTypeNode,
-                type: (0, utils_1.stringToNamedTypeNode)(defaultRootTypeName),
+                operation,
+                type: (0, utils_1.stringToNamedTypeNode)(value),
             });
         }
+        if (operationTypes.length > 0) {
+            const node = {
+                ...(schemaData.description ? { description: schemaData.description } : {}),
+                directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
+                kind: graphql_1.Kind.SCHEMA_DEFINITION,
+                operationTypes: operationTypes,
+            };
+            return node;
+        }
+        if (schemaData.directivesByName.size < 1) {
+            return;
+        }
         return {
-            description: schemaData.description,
-            directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByDirectiveName, schemaData.name),
-            kind: schemaData.kind,
-            operationTypes,
+            directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByName, schemaData.name),
+            kind: graphql_1.Kind.SCHEMA_EXTENSION,
         };
     }
     getUnionNodeByData(unionDefinitionData) {
         unionDefinitionData.node.description = unionDefinitionData.description;
-        unionDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(unionDefinitionData.directivesByDirectiveName, unionDefinitionData.name);
+        unionDefinitionData.node.directives = this.getValidFlattenedDirectiveArray(unionDefinitionData.directivesByName, unionDefinitionData.name);
         unionDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(unionDefinitionData.memberByMemberTypeName);
         return unionDefinitionData.node;
     }
@@ -2538,7 +2591,7 @@ class NormalizationFactory {
         }
     }
     validateOneOfDirective({ data, requiredFieldNames }) {
-        if (!data.directivesByDirectiveName.has(string_constants_1.ONE_OF)) {
+        if (!data.directivesByName.has(string_constants_1.ONE_OF)) {
             return true;
         }
         if (requiredFieldNames.size > 0) {
@@ -2577,25 +2630,6 @@ class NormalizationFactory {
         }
         definitions.push(...dependencies);
     }
-    #addSchemaDefinitionNode(definitions) {
-        const schemaNode = this.getSchemaNodeByData(this.schemaData);
-        if (schemaNode.operationTypes.length > 0) {
-            definitions.push(schemaNode);
-            return schemaNode;
-        }
-        if (!schemaNode.directives?.length) {
-            return;
-        }
-        return {
-            directives: schemaNode.directives,
-            kind: graphql_1.Kind.SCHEMA_EXTENSION,
-        };
-        // @TODO this currently breaks engine
-        // definitions.push({
-        //   directives: schemaNode.directives,
-        //   kind: Kind.SCHEMA_EXTENSION,
-        // });
-    }
     normalize(document) {
         // Collect any renamed root types
         (0, walkers_1.upsertDirectiveSchemaAndEntityDefinitions)(this, document);
@@ -2603,7 +2637,15 @@ class NormalizationFactory {
         const definitions = [];
         this.#addDirectiveDefinitionsToDocument(definitions);
         this.validateDirectives(this.schemaData, string_constants_1.SCHEMA);
-        const schemaNode = this.#addSchemaDefinitionNode(definitions);
+        const schemaNode = this.getSchemaNodeByData(this.schemaData);
+        /* Schema extension orphans are not supported on old routers.
+         * Consequently, it is a breaking change that requires a new composition version, and hat composition version
+         * would only be compatible with newer routers that support schema extension orphans.
+         * For now, only a valid schema definition node is pushed.
+         */
+        if (schemaNode?.kind === graphql_1.Kind.SCHEMA_DEFINITION) {
+            definitions.push(schemaNode);
+        }
         for (const [parentTypeName, parentData] of this.parentDefinitionDataByTypeName) {
             this.validateDirectives(parentData, parentTypeName);
         }
@@ -2739,7 +2781,10 @@ class NormalizationFactory {
                     this.addFieldNamesToConfigurationData(parentData.fieldDataByName, configurationData);
                     this.validateInterfaceImplementations(parentData);
                     definitions.push(this.getCompositeOutputNodeByData(parentData));
-                    // interfaces and objects must define at least one field
+                    /* Interfaces and Objects must define at least one field.
+                     * However, some servers allow a query root type to be defined without fields.
+                     * This is so it can be renamed and any federation boiler plate is appended to that renamed node.
+                     * */
                     if (parentData.fieldDataByName.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
                         this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_5.kindToNodeType)(parentData.kind), parentTypeName));
                     }