@wundergraph/composition 0.18.4 → 0.19.0

package/dist/schema-building/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeInheritableDirectivesFromParentWithFieldsData = exports.getUnionNodeByData = exports.getSchemaNodeByData = exports.getScalarNodeByData = exports.getParentWithFieldsNodeByData = exports.getInputObjectNodeByData = exports.getEnumNodeByData = exports.extractImplementedInterfaceTypeNames = exports.convertKindForExtension = exports.isTypeNameRootType = exports.upsertUnionExtensionDataByNode = exports.upsertUnionDefinitionDataByNode = exports.extractUniqueUnionMembers = exports.upsertScalarExtensionDataByNode = exports.upsertScalarDefinitionDataByNode = exports.upsertObjectDefinitionDataByNode = exports.upsertInterfaceDefinitionDataByNode = exports.upsertInputValueDataByNode = exports.upsertInputObjectExtensionDataByNode = exports.upsertInputObjectDefinitionDataByNode = exports.upsertExtensionWithFieldsDataByNode = exports.upsertFieldDataByNode = exports.addInheritedDirectivesToFieldData = exports.upsertEnumValueDataByNode = exports.upsertEnumExtensionDataByNode = exports.upsertEnumDefinitionDataByNode = exports.upsertArgumentDataByNode = exports.extractArguments = exports.extractDirectives = exports.getDirectiveValidationErrors = exports.getDefinedArgumentsForDirective = exports.isNodeExternalOrShareable = void 0;
+exports.isTypeValidImplementation = exports.MergeMethod = exports.isFieldExternalInAllMutualSubgraphs = exports.isShareabilityOfAllFieldInstancesValid = exports.addValidPersistedDirectiveDefinitionNodeByData = exports.getValidFieldArgumentNodes = exports.getNodeWithPersistedDirectivesByInputValueData = exports.getNodeWithPersistedDirectivesByFieldData = exports.getNodeWithPersistedDirectivesByData = exports.upsertValidObjectExtensionData = exports.pushAuthorizationDirectives = exports.upsertObjectExtensionData = exports.upsertParentDefinitionData = exports.removeInheritableDirectivesFromParentWithFieldsData = exports.getUnionNodeByData = exports.getSchemaNodeByData = exports.getScalarNodeByData = exports.getParentWithFieldsNodeByData = exports.getInputObjectNodeByData = exports.getEnumNodeByData = exports.extractImplementedInterfaceTypeNames = exports.convertKindForExtension = exports.getRenamedRootTypeName = exports.isTypeNameRootType = exports.addUnionExtensionDataByNode = exports.addUnionDefinitionDataByNode = exports.extractUniqueUnionMembers = exports.addScalarExtensionDataByNode = exports.addScalarDefinitionDataByNode = exports.upsertPersistedDirectiveDefinitionData = exports.addPersistedDirectiveDefinitionDataByNode = exports.addObjectDefinitionDataByNode = exports.addInterfaceDefinitionDataByNode = exports.addInputValueDataByNode = exports.addInputObjectExtensionDataByNode = exports.addInputObjectDefinitionDataByNode = exports.addExtensionWithFieldsDataByNode = exports.addFieldDataByNode = exports.addInheritedDirectivesToFieldData = exports.addEnumValueDataByNode = exports.addEnumExtensionDataByNode = exports.addEnumDefinitionDataByNode = exports.isTypeRequired = exports.extractArguments = exports.extractDirectives = exports.getDirectiveValidationErrors = exports.getDefinedArgumentsForDirective = exports.isNodeExternalOrShareable = void 0;
 const graphql_1 = require("graphql");
 const ast_1 = require("./ast");
 const utils_1 = require("../ast/utils");
@@ -10,6 +10,15 @@ const type_merging_1 = require("./type-merging");
 const utils_2 = require("../normalization/utils");
 const utils_3 = require("../utils/utils");
 const constants_1 = require("../utils/constants");
+const merge_1 = require("@graphql-tools/merge");
+function newPersistedDirectivesData() {
+    return {
+        deprecatedReason: '',
+        directives: new Map(),
+        isDeprecated: false,
+        tags: new Map(),
+    };
+}
 function isNodeExternalOrShareable(node, areAllFieldsShareable, directivesByDirectiveName) {
     const result = {
         isExternal: directivesByDirectiveName.has(string_constants_1.EXTERNAL),
@@ -141,13 +150,14 @@ function extractDirectives(node, directivesByDirectiveName, errors, directiveDef
     return directivesByDirectiveName;
 }
 exports.extractDirectives = extractDirectives;
-function extractArguments(argumentDataByArgumentName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentsWithChildArguments, parentTypeName, subgraphName) {
+function extractArguments(argumentDataByArgumentName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentsWithChildArguments, originalParentTypeName, renamedParentTypeName, subgraphName) {
     if (!node.arguments?.length) {
         return argumentDataByArgumentName;
     }
     const fieldName = node.name.value;
-    const fieldPath = `${parentTypeName}.${fieldName}`;
-    parentsWithChildArguments.add(parentTypeName);
+    const originalFieldPath = `${originalParentTypeName}.${fieldName}`;
+    const renamedFieldPath = `${renamedParentTypeName}.${fieldName}`;
+    parentsWithChildArguments.add(originalParentTypeName);
     const duplicatedArguments = new Set();
     for (const argumentNode of node.arguments) {
         const argumentName = argumentNode.name.value;
@@ -155,53 +165,88 @@ function extractArguments(argumentDataByArgumentName, node, errors, directiveDef
             duplicatedArguments.add(argumentName);
             continue;
         }
-        upsertArgumentDataByNode(argumentDataByArgumentName, argumentNode, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentTypeName, fieldName, subgraphName);
+        addInputValueDataByNode(argumentDataByArgumentName, argumentNode, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, `${originalFieldPath}(${argumentName}: ...)`, subgraphName, errors, `${renamedFieldPath}(${argumentName}: ...)`);
     }
     if (duplicatedArguments.size > 0) {
-        errors.push((0, errors_1.duplicateArgumentsError)(fieldPath, [...duplicatedArguments]));
+        errors.push((0, errors_1.duplicateArgumentsError)(originalFieldPath, [...duplicatedArguments]));
     }
     return argumentDataByArgumentName;
 }
 exports.extractArguments = extractArguments;
-function upsertArgumentDataByNode(argumentDataByArgumentName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentTypeName, fieldName, subgraphName) {
-    const name = node.name.value;
-    const hostPath = `${parentTypeName}.${fieldName}`;
-    argumentDataByArgumentName.set(name, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, `${hostPath}(${name}: ...)`, true),
-        name,
-        node: (0, ast_1.getMutableInputValueNode)(node, parentTypeName, fieldName),
-        requiredSubgraphNames: new Set([subgraphName]),
-        subgraphNames: new Set([subgraphName]),
-        type: (0, ast_1.getMutableTypeNode)(node.type, hostPath),
-        defaultValue: node.defaultValue,
-        description: (0, utils_1.formatDescription)(node.description),
-    });
+function isTypeRequired(node) {
+    return node.kind === graphql_1.Kind.NON_NULL_TYPE;
 }
-exports.upsertArgumentDataByNode = upsertArgumentDataByNode;
-function upsertEnumDefinitionDataByNode(parentDefinitionDataByTypeName, node, directivesByDirectiveName) {
-    const typeName = node.name.value;
-    parentDefinitionDataByTypeName.set(typeName, {
+exports.isTypeRequired = isTypeRequired;
+// TODO replace naïve comparison
+function areDefaultValuesCompatible(typeNode, incomingDefaultValue) {
+    switch (typeNode.kind) {
+        case graphql_1.Kind.LIST_TYPE:
+            return incomingDefaultValue.kind === graphql_1.Kind.LIST || incomingDefaultValue.kind === graphql_1.Kind.NULL;
+        case graphql_1.Kind.NAMED_TYPE:
+            if (incomingDefaultValue.kind === graphql_1.Kind.NULL) {
+                return true;
+            }
+            switch (typeNode.name.value) {
+                case string_constants_1.BOOLEAN_SCALAR:
+                    return incomingDefaultValue.kind === graphql_1.Kind.BOOLEAN;
+                case string_constants_1.FLOAT_SCALAR:
+                    return incomingDefaultValue.kind === graphql_1.Kind.INT || incomingDefaultValue.kind === graphql_1.Kind.FLOAT;
+                case string_constants_1.INT_SCALAR:
+                    return incomingDefaultValue.kind === graphql_1.Kind.INT;
+                case string_constants_1.STRING_SCALAR:
+                    return incomingDefaultValue.kind === graphql_1.Kind.STRING;
+                default:
+                    return true;
+            }
+        case graphql_1.Kind.NON_NULL_TYPE:
+            if (incomingDefaultValue.kind === graphql_1.Kind.NULL) {
+                return false;
+            }
+            return areDefaultValuesCompatible(typeNode.type, incomingDefaultValue);
+    }
+}
+function compareAndValidateInputValueDefaultValues(existingData, incomingData, errors) {
+    if (!existingData.defaultValue) {
+        // TODO warning if default value in incoming
+        return;
+    }
+    if (!incomingData.defaultValue) {
+        // TODO warning
+        existingData.includeDefaultValue = false;
+        return;
+    }
+    const existingDefaultValueString = (0, graphql_1.print)(existingData.defaultValue);
+    const incomingDefaultValueString = (0, graphql_1.print)(incomingData.defaultValue);
+    if (existingDefaultValueString !== incomingDefaultValueString) {
+        errors.push((0, errors_1.incompatibleInputValueDefaultValuesError)(`${existingData.isArgument ? 'argument' : 'input value'} "${existingData.name}"`, existingData.originalPath, [...incomingData.subgraphNames], existingDefaultValueString, incomingDefaultValueString));
+        return;
+    }
+}
+function addEnumDefinitionDataByNode(parentDefinitionDataByTypeName, node, directivesByDirectiveName) {
+    const name = node.name.value;
+    parentDefinitionDataByTypeName.set(name, {
         appearances: 1,
         directivesByDirectiveName,
+        enumValueDataByValueName: new Map(),
         kind: node.kind,
         node: (0, ast_1.getMutableEnumNode)(node),
-        typeName,
-        enumValueDataByValueName: new Map(),
+        persistedDirectivesData: newPersistedDirectivesData(),
+        name,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertEnumDefinitionDataByNode = upsertEnumDefinitionDataByNode;
-function upsertEnumExtensionDataByNode(parentExtensionDataByTypeName, node, directivesByDirectiveName) {
-    const typeName = node.name.value;
-    parentExtensionDataByTypeName.set(typeName, {
+exports.addEnumDefinitionDataByNode = addEnumDefinitionDataByNode;
+function addEnumExtensionDataByNode(parentExtensionDataByTypeName, node, directivesByDirectiveName) {
+    const name = node.name.value;
+    parentExtensionDataByTypeName.set(name, {
         directivesByDirectiveName,
         enumValueDataByValueName: new Map(),
         kind: node.kind,
-        typeName,
+        name,
     });
 }
-exports.upsertEnumExtensionDataByNode = upsertEnumExtensionDataByNode;
-function upsertEnumValueDataByNode(enumValueDataByValueName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentTypeName) {
+exports.addEnumExtensionDataByNode = addEnumExtensionDataByNode;
+function addEnumValueDataByNode(enumValueDataByValueName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentTypeName) {
     const name = node.name.value;
     enumValueDataByValueName.set(name, {
         appearances: 1,
@@ -209,10 +254,11 @@ function upsertEnumValueDataByNode(enumValueDataByValueName, node, errors, direc
         name,
         node: (0, ast_1.getMutableEnumValueNode)(node),
         parentTypeName,
+        persistedDirectivesData: newPersistedDirectivesData(),
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertEnumValueDataByNode = upsertEnumValueDataByNode;
+exports.addEnumValueDataByNode = addEnumValueDataByNode;
 function addInheritedDirectivesToFieldData(parentDirectivesByDirectiveName, fieldDirectivesByDirectiveName) {
     for (const directiveName of constants_1.INHERITABLE_DIRECTIVE_NAMES) {
         if (parentDirectivesByDirectiveName.get(directiveName)) {
@@ -222,139 +268,233 @@ function addInheritedDirectivesToFieldData(parentDirectivesByDirectiveName, fiel
     return fieldDirectivesByDirectiveName;
 }
 exports.addInheritedDirectivesToFieldData = addInheritedDirectivesToFieldData;
-function upsertFieldDataByNode(fieldDataByFieldName, node, errors, argumentDataByArgumentName, directivesByDirectiveName, parentTypeName, subgraphName, isSubgraphVersionTwo) {
+function addFieldDataByNode(fieldDataByFieldName, node, errors, argumentDataByArgumentName, directivesByDirectiveName, originalParentTypeName, renamedParentTypeName, subgraphName, isSubgraphVersionTwo) {
     const name = node.name.value;
-    const fieldPath = `${parentTypeName}.${name}`;
+    const fieldPath = `${originalParentTypeName}.${name}`;
     const isNodeExternalOrShareableResult = isNodeExternalOrShareable(node, !isSubgraphVersionTwo, directivesByDirectiveName);
     const fieldData = {
         argumentDataByArgumentName: argumentDataByArgumentName,
         isExternalBySubgraphName: new Map([[subgraphName, isNodeExternalOrShareableResult.isExternal]]),
+        isInaccessible: directivesByDirectiveName.has(string_constants_1.INACCESSIBLE),
         isShareableBySubgraphName: new Map([[subgraphName, isNodeExternalOrShareableResult.isShareable]]),
-        node: (0, ast_1.getMutableFieldNode)(node, parentTypeName),
+        node: (0, ast_1.getMutableFieldNode)(node, fieldPath),
         name,
-        namedTypeName: (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type),
-        parentTypeName,
+        namedTypeName: (0, ast_1.getTypeNodeNamedTypeName)(node.type),
+        originalParentTypeName,
+        persistedDirectivesData: newPersistedDirectivesData(),
+        renamedParentTypeName,
         subgraphNames: new Set([subgraphName]),
+        type: (0, ast_1.getMutableTypeNode)(node.type, fieldPath),
         directivesByDirectiveName,
         description: (0, utils_1.formatDescription)(node.description),
     };
     fieldDataByFieldName.set(name, fieldData);
     return fieldData;
 }
-exports.upsertFieldDataByNode = upsertFieldDataByNode;
-function upsertExtensionWithFieldsDataByNode(parentExtensionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity) {
-    const typeName = node.name.value;
+exports.addFieldDataByNode = addFieldDataByNode;
+function addExtensionWithFieldsDataByNode(parentExtensionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity, isRootType, subgraphName, renamedTypeName) {
+    const name = node.name.value;
     const kind = convertKindForExtension(node);
     switch (kind) {
         case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
-            parentExtensionDataByTypeName.set(typeName, {
-                directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+            parentExtensionDataByTypeName.set(name, {
+                directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
                 fieldDataByFieldName: new Map(),
                 implementedInterfaceTypeNames: extractImplementedInterfaceTypeNames(node, new Set(), errors),
                 isEntity,
                 kind,
-                typeName,
+                name,
             });
             return;
         default:
-            parentExtensionDataByTypeName.set(typeName, {
-                directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+            parentExtensionDataByTypeName.set(name, {
+                directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
                 fieldDataByFieldName: new Map(),
                 implementedInterfaceTypeNames: extractImplementedInterfaceTypeNames(node, new Set(), errors),
                 isEntity,
+                isRootType,
                 kind,
+                name,
                 node: (0, ast_1.getMutableObjectExtensionNode)(node),
-                typeName,
+                persistedDirectivesData: newPersistedDirectivesData(),
+                renamedTypeName: renamedTypeName || name,
+                subgraphNames: new Set([subgraphName]),
             });
     }
 }
-exports.upsertExtensionWithFieldsDataByNode = upsertExtensionWithFieldsDataByNode;
-function upsertInputObjectDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath) {
-    const typeName = node.name.value;
-    parentDefinitionDataByTypeName.set(typeName, {
-        appearances: 1,
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+exports.addExtensionWithFieldsDataByNode = addExtensionWithFieldsDataByNode;
+function addInputObjectDefinitionDataByNode(parentDefinitionDataByTypeName, node, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, subgraphName, errors) {
+    const name = node.name.value;
+    parentDefinitionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         inputValueDataByValueName: new Map(),
         kind: node.kind,
         node: (0, ast_1.getMutableInputObjectNode)(node),
-        typeName,
+        persistedDirectivesData: newPersistedDirectivesData(),
+        name,
+        subgraphNames: new Set([subgraphName]),
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertInputObjectDefinitionDataByNode = upsertInputObjectDefinitionDataByNode;
-function upsertInputObjectExtensionDataByNode(parentExtensionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath) {
-    const typeName = node.name.value;
-    parentExtensionDataByTypeName.set(typeName, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+exports.addInputObjectDefinitionDataByNode = addInputObjectDefinitionDataByNode;
+function addInputObjectExtensionDataByNode(parentExtensionDataByTypeName, node, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, errors) {
+    const name = node.name.value;
+    parentExtensionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         inputValueDataByValueName: new Map(),
         kind: node.kind,
-        typeName,
+        name,
     });
 }
-exports.upsertInputObjectExtensionDataByNode = upsertInputObjectExtensionDataByNode;
-function upsertInputValueDataByNode(inputValueDataByValueName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, parentTypeName) {
+exports.addInputObjectExtensionDataByNode = addInputObjectExtensionDataByNode;
+function addInputValueDataByNode(inputValueDataByValueName, node, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, originalPath, subgraphName, errors, renamedPath) {
     const name = node.name.value;
+    // Only arguments have renamed paths
+    const isArgument = !!renamedPath;
+    if (node.defaultValue && !areDefaultValuesCompatible(node.type, node.defaultValue)) {
+        errors.push((0, errors_1.incompatibleInputValueDefaultValueTypeError)((isArgument ? 'argument' : 'input field') + ` "${name}"`, originalPath, (0, merge_1.printTypeNode)(node.type), (0, graphql_1.print)(node.defaultValue)));
+    }
     inputValueDataByValueName.set(name, {
-        appearances: 1,
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, `${parentTypeName}.${name}`),
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, originalPath, isArgument),
+        includeDefaultValue: !!node.defaultValue,
+        isArgument,
         name,
-        node: (0, ast_1.getMutableInputValueNode)(node, parentTypeName, name),
-        parentTypeName,
+        node: (0, ast_1.getMutableInputValueNode)(node, originalPath),
+        originalPath,
+        persistedDirectivesData: newPersistedDirectivesData(),
+        renamedPath: renamedPath || originalPath,
+        requiredSubgraphNames: new Set(isTypeRequired(node.type) ? [subgraphName] : []),
+        subgraphNames: new Set([subgraphName]),
+        type: (0, ast_1.getMutableTypeNode)(node.type, originalPath),
+        defaultValue: node.defaultValue,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertInputValueDataByNode = upsertInputValueDataByNode;
-function upsertInterfaceDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity, subgraphName) {
-    const typeName = node.name.value;
-    parentDefinitionDataByTypeName.set(typeName, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+exports.addInputValueDataByNode = addInputValueDataByNode;
+function addInterfaceDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity, subgraphName) {
+    const name = node.name.value;
+    parentDefinitionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         fieldDataByFieldName: new Map(),
         isEntity,
         implementedInterfaceTypeNames: extractImplementedInterfaceTypeNames(node, new Set(), errors),
         kind: node.kind,
         node: (0, ast_1.getMutableInterfaceNode)(node),
+        persistedDirectivesData: newPersistedDirectivesData(),
         subgraphNames: new Set([subgraphName]),
-        typeName,
+        name,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertInterfaceDefinitionDataByNode = upsertInterfaceDefinitionDataByNode;
-function upsertObjectDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity, isRootType, subgraphName) {
-    const typeName = node.name.value;
-    parentDefinitionDataByTypeName.set(typeName, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+exports.addInterfaceDefinitionDataByNode = addInterfaceDefinitionDataByNode;
+function addObjectDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, isEntity, isRootType, subgraphName, renamedTypeName) {
+    const name = node.name.value;
+    parentDefinitionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         fieldDataByFieldName: new Map(),
         isEntity,
         isRootType,
         implementedInterfaceTypeNames: extractImplementedInterfaceTypeNames(node, new Set(), errors),
         kind: node.kind,
+        name,
         node: (0, ast_1.getMutableObjectNode)(node),
+        persistedDirectivesData: newPersistedDirectivesData(),
+        renamedTypeName: renamedTypeName || name,
+        subgraphNames: new Set([subgraphName]),
+        description: (0, utils_1.formatDescription)(node.description),
+    });
+}
+exports.addObjectDefinitionDataByNode = addObjectDefinitionDataByNode;
+function addPersistedDirectiveDefinitionDataByNode(persistedDirectiveDefinitionDataByDirectiveName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, executableLocations, subgraphName) {
+    const name = node.name.value;
+    const argumentDataByArgumentName = new Map();
+    for (const argumentNode of node.arguments || []) {
+        const originalPath = `@${name}(${argumentNode.name.value}: ...)`;
+        addInputValueDataByNode(argumentDataByArgumentName, argumentNode, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, originalPath, subgraphName, errors, originalPath);
+    }
+    persistedDirectiveDefinitionDataByDirectiveName.set(name, {
+        argumentDataByArgumentName,
+        executableLocations,
+        name: name,
+        repeatable: node.repeatable,
         subgraphNames: new Set([subgraphName]),
-        typeName,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertObjectDefinitionDataByNode = upsertObjectDefinitionDataByNode;
-function upsertScalarDefinitionDataByNode(parentDefinitionDataByTypeName, node, directivesByDirectiveName) {
-    const typeName = node.name.value;
-    parentDefinitionDataByTypeName.set(typeName, {
+exports.addPersistedDirectiveDefinitionDataByNode = addPersistedDirectiveDefinitionDataByNode;
+function setMutualExecutableLocations(persistedDirectiveDefinitionData, incomingExecutableLocations) {
+    const mutualExecutableLocations = new Set();
+    for (const incomingExecutableLocation of incomingExecutableLocations) {
+        if (persistedDirectiveDefinitionData.executableLocations.has(incomingExecutableLocation)) {
+            mutualExecutableLocations.add(incomingExecutableLocation);
+        }
+    }
+    persistedDirectiveDefinitionData.executableLocations = mutualExecutableLocations;
+}
+function upsertPersistedDirectiveDefinitionData(persistedDirectiveDefinitionDataByDirectiveName, incomingData, persistedDirectiveDefinitionByDirectiveName, namedInputValueTypeNames, subgraphNumber, errors) {
+    const name = incomingData.name;
+    const existingData = persistedDirectiveDefinitionDataByDirectiveName.get(name);
+    if (!existingData) {
+        // The executable directive must be defined in all subgraphs to be persisted.
+        if (subgraphNumber > 1) {
+            return;
+        }
+        const argumentDataByArgumentName = new Map();
+        for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+            namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+            upsertInputValueData(argumentDataByArgumentName, inputValueData, persistedDirectiveDefinitionByDirectiveName, errors);
+        }
+        persistedDirectiveDefinitionDataByDirectiveName.set(name, {
+            argumentDataByArgumentName,
+            executableLocations: new Set(incomingData.executableLocations),
+            name,
+            repeatable: incomingData.repeatable,
+            subgraphNames: new Set(incomingData.subgraphNames),
+            description: incomingData.description,
+        });
+        return;
+    }
+    // If the executable directive has not been defined in at least one graph, the definition should not be persisted
+    if (existingData.subgraphNames.size + 1 !== subgraphNumber) {
+        persistedDirectiveDefinitionDataByDirectiveName.delete(name);
+        return;
+    }
+    setMutualExecutableLocations(existingData, incomingData.executableLocations);
+    // If there are no mutually defined executable locations, the definition should not be persisted
+    if (existingData.executableLocations.size < 1) {
+        persistedDirectiveDefinitionDataByDirectiveName.delete(name);
+        return;
+    }
+    for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+        namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+        upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData, persistedDirectiveDefinitionByDirectiveName, errors);
+    }
+    setLongestDescription(existingData, incomingData);
+    existingData.repeatable &&= incomingData.repeatable;
+    (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+}
+exports.upsertPersistedDirectiveDefinitionData = upsertPersistedDirectiveDefinitionData;
+function addScalarDefinitionDataByNode(parentDefinitionDataByTypeName, node, directivesByDirectiveName) {
+    const name = node.name.value;
+    parentDefinitionDataByTypeName.set(name, {
         directivesByDirectiveName,
         kind: node.kind,
         node: (0, ast_1.getMutableScalarNode)(node),
-        typeName,
+        persistedDirectivesData: newPersistedDirectivesData(),
+        name,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertScalarDefinitionDataByNode = upsertScalarDefinitionDataByNode;
-function upsertScalarExtensionDataByNode(parentExtensionDataByTypeName, node, directivesByDirectiveName) {
-    const typeName = node.name.value;
-    parentExtensionDataByTypeName.set(typeName, {
+exports.addScalarDefinitionDataByNode = addScalarDefinitionDataByNode;
+function addScalarExtensionDataByNode(parentExtensionDataByTypeName, node, directivesByDirectiveName) {
+    const name = node.name.value;
+    parentExtensionDataByTypeName.set(name, {
         directivesByDirectiveName,
         kind: node.kind,
-        typeName,
+        name,
     });
 }
-exports.upsertScalarExtensionDataByNode = upsertScalarExtensionDataByNode;
+exports.addScalarExtensionDataByNode = addScalarExtensionDataByNode;
 function extractUniqueUnionMembers(members, membersByMemberTypeName, errors, unionTypeName, abstractToConcreteTypeNames, referencedTypeNames) {
     for (const member of members) {
         const memberTypeName = member.name.value;
@@ -377,38 +517,54 @@ function extractUniqueUnionMembers(members, membersByMemberTypeName, errors, uni
     return membersByMemberTypeName;
 }
 exports.extractUniqueUnionMembers = extractUniqueUnionMembers;
-function upsertUnionDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, abstractToConcreteTypeNames, referencedTypeNames) {
-    const typeName = node.name.value;
+function addUnionDefinitionDataByNode(parentDefinitionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, abstractToConcreteTypeNames, referencedTypeNames) {
+    const name = node.name.value;
     if (!node.types?.length) {
-        errors.push((0, errors_1.noDefinedUnionMembersError)(typeName));
+        errors.push((0, errors_1.noDefinedUnionMembersError)(name));
         return;
     }
-    parentDefinitionDataByTypeName.set(typeName, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+    parentDefinitionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         kind: node.kind,
-        memberByMemberTypeName: extractUniqueUnionMembers(node.types, new Map(), errors, typeName, abstractToConcreteTypeNames, referencedTypeNames),
+        memberByMemberTypeName: extractUniqueUnionMembers(node.types, new Map(), errors, name, abstractToConcreteTypeNames, referencedTypeNames),
         node: (0, ast_1.getMutableUnionNode)(node),
-        typeName,
+        persistedDirectivesData: newPersistedDirectivesData(),
+        name,
         description: (0, utils_1.formatDescription)(node.description),
     });
 }
-exports.upsertUnionDefinitionDataByNode = upsertUnionDefinitionDataByNode;
-function upsertUnionExtensionDataByNode(parentExtensionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, abstractToConcreteTypeNames, referencedTypeNames) {
-    const typeName = node.name.value;
-    parentExtensionDataByTypeName.set(typeName, {
-        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, typeName),
+exports.addUnionDefinitionDataByNode = addUnionDefinitionDataByNode;
+function addUnionExtensionDataByNode(parentExtensionDataByTypeName, node, errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, abstractToConcreteTypeNames, referencedTypeNames) {
+    const name = node.name.value;
+    parentExtensionDataByTypeName.set(name, {
+        directivesByDirectiveName: extractDirectives(node, new Map(), errors, directiveDefinitionByDirectiveName, handledRepeatedDirectivesByHostPath, name),
         kind: node.kind,
         memberByMemberTypeName: extractUniqueUnionMembers(
         // Undefined or empty node.types is handled earlier
-        node.types, new Map(), errors, typeName, abstractToConcreteTypeNames, referencedTypeNames),
-        typeName,
+        node.types, new Map(), errors, name, abstractToConcreteTypeNames, referencedTypeNames),
+        name,
     });
 }
-exports.upsertUnionExtensionDataByNode = upsertUnionExtensionDataByNode;
+exports.addUnionExtensionDataByNode = addUnionExtensionDataByNode;
 function isTypeNameRootType(typeName, operationByTypeName) {
     return string_constants_1.ROOT_TYPES.has(typeName) || operationByTypeName.has(typeName);
 }
 exports.isTypeNameRootType = isTypeNameRootType;
+function getRenamedRootTypeName(typeName, operationByTypeName) {
+    const operationTypeNode = operationByTypeName.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;
+    }
+}
+exports.getRenamedRootTypeName = getRenamedRootTypeName;
 function convertKindForExtension(node) {
     switch (node.kind) {
         case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
@@ -450,7 +606,7 @@ function addExtensionDirectivesToDefinition(directivesByDirectiveName, parentExt
     }
 }
 function addAuthorizationDirectivesToFieldData(authorizationDataByParentTypeName, fieldData) {
-    const authorizationData = authorizationDataByParentTypeName.get(fieldData.parentTypeName);
+    const authorizationData = authorizationDataByParentTypeName.get(fieldData.originalParentTypeName);
     if (!authorizationData) {
         return;
     }
@@ -537,7 +693,7 @@ function mergeUniqueUnionMembers(unionDefinitionData, errors, unionExtensionData
     }
     const definitionMembers = unionDefinitionData.memberByMemberTypeName;
     const extensionMembers = unionExtensionData.memberByMemberTypeName;
-    const typeName = unionDefinitionData.typeName;
+    const typeName = unionDefinitionData.name;
     for (const [memberName, namedTypeNode] of extensionMembers) {
         if (!definitionMembers.has(memberName)) {
             definitionMembers.set(memberName, namedTypeNode);
@@ -548,21 +704,21 @@ function mergeUniqueUnionMembers(unionDefinitionData, errors, unionExtensionData
 }
 function getEnumNodeByData(enumDefinitionData, errors, directiveDefinitionByDirectiveName, authorizationDataByParentTypeName, enumExtensionData) {
     addExtensionDirectivesToDefinition(enumDefinitionData.directivesByDirectiveName, enumExtensionData);
-    enumDefinitionData.node.directives = getValidFlattenedDirectiveArray(enumDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, enumDefinitionData.typeName);
+    enumDefinitionData.node.directives = getValidFlattenedDirectiveArray(enumDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, enumDefinitionData.name);
     enumDefinitionData.node.values = childMapToValueArray(enumDefinitionData.enumValueDataByValueName, authorizationDataByParentTypeName);
     return enumDefinitionData.node;
 }
 exports.getEnumNodeByData = getEnumNodeByData;
 function getInputObjectNodeByData(inputObjectDefinitionData, errors, directiveDefinitionByDirectiveName, authorizationDataByParentTypeName, inputObjectExtensionData) {
     addExtensionDirectivesToDefinition(inputObjectDefinitionData.directivesByDirectiveName, inputObjectExtensionData);
-    inputObjectDefinitionData.node.directives = getValidFlattenedDirectiveArray(inputObjectDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, inputObjectDefinitionData.typeName);
+    inputObjectDefinitionData.node.directives = getValidFlattenedDirectiveArray(inputObjectDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, inputObjectDefinitionData.name);
     inputObjectDefinitionData.node.fields = childMapToValueArray(inputObjectDefinitionData.inputValueDataByValueName, authorizationDataByParentTypeName);
     return inputObjectDefinitionData.node;
 }
 exports.getInputObjectNodeByData = getInputObjectNodeByData;
 function getParentWithFieldsNodeByData(parentWithFieldsData, errors, directiveDefinitionByDirectiveName, authorizationDataByParentTypeName, parentExtensionWithFieldsData) {
     addExtensionDirectivesToDefinition(parentWithFieldsData.directivesByDirectiveName, parentExtensionWithFieldsData);
-    parentWithFieldsData.node.directives = getValidFlattenedDirectiveArray(parentWithFieldsData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, parentWithFieldsData.typeName);
+    parentWithFieldsData.node.directives = getValidFlattenedDirectiveArray(parentWithFieldsData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, parentWithFieldsData.name);
     parentWithFieldsData.node.fields = childMapToValueArray(parentWithFieldsData.fieldDataByFieldName, authorizationDataByParentTypeName);
     parentWithFieldsData.node.interfaces = (0, utils_1.setToNamedTypeNodeArray)(parentWithFieldsData.implementedInterfaceTypeNames);
     return parentWithFieldsData.node;
@@ -570,7 +726,7 @@ function getParentWithFieldsNodeByData(parentWithFieldsData, errors, directiveDe
 exports.getParentWithFieldsNodeByData = getParentWithFieldsNodeByData;
 function getScalarNodeByData(scalarDefinitionData, errors, directiveDefinitionByDirectiveName, scalarExtensionData) {
     addExtensionDirectivesToDefinition(scalarDefinitionData.directivesByDirectiveName, scalarExtensionData);
-    scalarDefinitionData.node.directives = getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, scalarDefinitionData.typeName);
+    scalarDefinitionData.node.directives = getValidFlattenedDirectiveArray(scalarDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, scalarDefinitionData.name);
     return scalarDefinitionData.node;
 }
 exports.getScalarNodeByData = getScalarNodeByData;
@@ -586,7 +742,7 @@ exports.getSchemaNodeByData = getSchemaNodeByData;
 function getUnionNodeByData(unionDefinitionData, errors, directiveDefinitionByDirectiveName, unionExtensionData) {
     mergeUniqueUnionMembers(unionDefinitionData, errors, unionExtensionData);
     addExtensionDirectivesToDefinition(unionDefinitionData.directivesByDirectiveName, unionExtensionData);
-    unionDefinitionData.node.directives = getValidFlattenedDirectiveArray(unionDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, unionDefinitionData.typeName);
+    unionDefinitionData.node.directives = getValidFlattenedDirectiveArray(unionDefinitionData.directivesByDirectiveName, errors, directiveDefinitionByDirectiveName, unionDefinitionData.name);
     unionDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(unionDefinitionData.memberByMemberTypeName);
     return unionDefinitionData.node;
 }
@@ -597,4 +753,592 @@ function removeInheritableDirectivesFromParentWithFieldsData(parentData) {
     }
 }
 exports.removeInheritableDirectivesFromParentWithFieldsData = removeInheritableDirectivesFromParentWithFieldsData;
+function setLongestDescription(existingData, incomingData) {
+    if (!incomingData.description) {
+        return;
+    }
+    if (!existingData.description || existingData.description.value.length < incomingData.description.value.length) {
+        existingData.description = { ...incomingData.description, block: true };
+    }
+}
+function upsertDeprecatedDirective(persistedDirectivesData, incomingDirectiveNode) {
+    if (!incomingDirectiveNode.arguments?.length) {
+        return;
+    }
+    // The argument was already validated in the normalization factory, so it can be safely cast
+    const incomingReasonString = incomingDirectiveNode.arguments[0].value.value;
+    if (persistedDirectivesData.deprecatedReason.length < incomingReasonString.length) {
+        persistedDirectivesData.deprecatedReason = incomingReasonString;
+    }
+}
+function upsertTagDirectives(persistedDirectivesData, incomingDirectiveNodes) {
+    for (const incomingDirectiveNode of incomingDirectiveNodes) {
+        // The argument was already validated in the normalization factory, so it can be safely cast
+        const incomingNameString = incomingDirectiveNode.arguments[0].value.value;
+        persistedDirectivesData.tags.set(incomingNameString, incomingDirectiveNode);
+    }
+}
+function extractPersistedDirectives(persistedDirectivesData, directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName) {
+    for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
+        if (!persistedDirectiveDefinitionByDirectiveName.has(directiveName)) {
+            continue;
+        }
+        if (directiveName === string_constants_1.DEPRECATED) {
+            persistedDirectivesData.isDeprecated = true;
+            upsertDeprecatedDirective(persistedDirectivesData, directiveNodes[0]);
+            continue;
+        }
+        if (directiveName === string_constants_1.TAG) {
+            upsertTagDirectives(persistedDirectivesData, directiveNodes);
+            continue;
+        }
+        const existingDirectives = persistedDirectivesData.directives.get(directiveName);
+        if (!existingDirectives) {
+            persistedDirectivesData.directives.set(directiveName, directiveNodes);
+            continue;
+        }
+        existingDirectives.push(...directiveNodes);
+    }
+    return persistedDirectivesData;
+}
+function upsertEnumValueData(enumValueDataByValueName, incomingData, persistedDirectiveDefinitionByDirectiveName) {
+    const existingData = enumValueDataByValueName.get(incomingData.name);
+    extractPersistedDirectives(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+    if (!existingData) {
+        incomingData.node = {
+            directives: [],
+            kind: incomingData.node.kind,
+            name: (0, utils_1.stringToNameNode)(incomingData.name),
+        };
+        enumValueDataByValueName.set(incomingData.name, incomingData);
+        return;
+    }
+    existingData.appearances += 1;
+    setLongestDescription(existingData, incomingData);
+}
+function upsertFieldData(fieldDataByFieldName, incomingData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors) {
+    namedOutputTypeNames.add(incomingData.namedTypeName);
+    const existingData = fieldDataByFieldName.get(incomingData.name);
+    extractPersistedDirectives(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+    if (!existingData) {
+        fieldDataByFieldName.set(incomingData.name, incomingData);
+        incomingData.node = {
+            arguments: [],
+            directives: [],
+            kind: incomingData.node.kind,
+            name: (0, utils_1.stringToNameNode)(incomingData.name),
+            type: incomingData.type,
+        };
+        for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+            inputValueData.node = {
+                directives: [],
+                kind: inputValueData.node.kind,
+                name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                type: inputValueData.type,
+            };
+            namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+            extractPersistedDirectives(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+        }
+        return;
+    }
+    const fieldPath = `${existingData.renamedParentTypeName}.${existingData.name}`;
+    const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingData.type, incomingData.type, fieldPath);
+    if (typeNode) {
+        existingData.type = typeNode;
+    }
+    else {
+        if (!typeErrors || typeErrors.length < 2) {
+            throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+        }
+        errors.push((0, errors_1.incompatibleChildTypesError)(fieldPath, typeErrors[0], typeErrors[1]));
+    }
+    for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+        namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+        upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData, persistedDirectiveDefinitionByDirectiveName, errors);
+    }
+    setLongestDescription(existingData, incomingData);
+    existingData.isInaccessible ||= incomingData.isInaccessible;
+    (0, utils_3.addMapEntries)(incomingData.isExternalBySubgraphName, existingData.isExternalBySubgraphName);
+    (0, utils_3.addMapEntries)(incomingData.isShareableBySubgraphName, existingData.isShareableBySubgraphName);
+    (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+}
+function upsertInputValueData(inputValueDataByValueName, incomingData, persistedDirectiveDefinitionByDirectiveName, errors) {
+    const existingData = inputValueDataByValueName.get(incomingData.name);
+    extractPersistedDirectives(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+    if (!existingData) {
+        incomingData.node = {
+            directives: [],
+            kind: incomingData.node.kind,
+            name: (0, utils_1.stringToNameNode)(incomingData.name),
+            type: incomingData.type,
+        };
+        inputValueDataByValueName.set(incomingData.name, incomingData);
+        return;
+    }
+    setLongestDescription(existingData, incomingData);
+    (0, utils_3.addIterableValuesToSet)(incomingData.requiredSubgraphNames, existingData.requiredSubgraphNames);
+    (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+    // TODO refactor type merging
+    const { typeErrors, typeNode } = (0, type_merging_1.getMostRestrictiveMergedTypeNode)(existingData.type, incomingData.type, existingData.originalPath);
+    if (typeNode) {
+        existingData.type = typeNode;
+    }
+    else {
+        if (!typeErrors || typeErrors.length < 2) {
+            throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+        }
+        existingData.isArgument
+            ? errors.push((0, errors_1.incompatibleArgumentTypesError)(existingData.name, existingData.renamedPath, typeErrors[0], typeErrors[1]))
+            : errors.push((0, errors_1.incompatibleChildTypesError)(existingData.renamedPath, typeErrors[0], typeErrors[1]));
+    }
+    compareAndValidateInputValueDefaultValues(existingData, incomingData, errors);
+}
+function upsertParentDefinitionData(parentDefinitionDataByTypeName, incomingData, persistedDirectiveDefinitionByDirectiveName, entityInterfaceFederationDataByTypeName, namedOutputTypeNames, namedInputValueTypeNames, subgraphName, errors) {
+    const entityInterfaceData = entityInterfaceFederationDataByTypeName.get(incomingData.name);
+    const existingData = parentDefinitionDataByTypeName.get(incomingData.name);
+    extractPersistedDirectives(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+    if (!existingData) {
+        if (entityInterfaceData && entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName)) {
+            incomingData.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
+        }
+        incomingData.node = {
+            kind: incomingData.kind,
+            name: (0, utils_1.stringToNameNode)(incomingData.name),
+        };
+        parentDefinitionDataByTypeName.set(incomingData.name, incomingData);
+        switch (incomingData.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                for (const enumValueData of incomingData.enumValueDataByValueName.values()) {
+                    enumValueData.node = {
+                        directives: [],
+                        kind: enumValueData.node.kind,
+                        name: (0, utils_1.stringToNameNode)(enumValueData.name),
+                    };
+                    extractPersistedDirectives(enumValueData.persistedDirectivesData, enumValueData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+                }
+                return;
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                for (const inputValueData of incomingData.inputValueDataByValueName.values()) {
+                    inputValueData.node = {
+                        directives: [],
+                        kind: inputValueData.node.kind,
+                        name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                        type: inputValueData.type,
+                    };
+                    namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+                    extractPersistedDirectives(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+                }
+                return;
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            // intentional fallthrough
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+                    fieldData.node = {
+                        arguments: [],
+                        directives: [],
+                        kind: fieldData.node.kind,
+                        name: (0, utils_1.stringToNameNode)(fieldData.name),
+                        type: fieldData.type,
+                    };
+                    namedOutputTypeNames.add(fieldData.namedTypeName);
+                    extractPersistedDirectives(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+                    for (const inputValueData of fieldData.argumentDataByArgumentName.values()) {
+                        inputValueData.node = {
+                            directives: [],
+                            kind: inputValueData.node.kind,
+                            name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                            type: inputValueData.type,
+                        };
+                        namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+                        extractPersistedDirectives(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+                    }
+                }
+                return;
+            default:
+                // Scalar and Union
+                return;
+        }
+    }
+    setLongestDescription(existingData, incomingData);
+    if (existingData.kind !== incomingData.kind) {
+        if (!entityInterfaceData ||
+            !entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName) ||
+            existingData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+            incomingData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            throw (0, errors_1.incompatibleParentKindFatalError)(existingData.name, existingData.kind, incomingData.kind);
+        }
+    }
+    switch (existingData.kind) {
+        case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+            existingData.appearances += 1;
+            for (const data of incomingData.enumValueDataByValueName.values()) {
+                upsertEnumValueData(existingData.enumValueDataByValueName, data, persistedDirectiveDefinitionByDirectiveName);
+            }
+            return;
+        case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+            for (const inputValueData of incomingData.inputValueDataByValueName.values()) {
+                namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+                upsertInputValueData(existingData.inputValueDataByValueName, inputValueData, persistedDirectiveDefinitionByDirectiveName, errors);
+            }
+            return;
+        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+        // intentional fallthrough
+        case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+            const objectData = incomingData;
+            (0, utils_3.addIterableValuesToSet)(objectData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+            (0, utils_3.addIterableValuesToSet)(objectData.subgraphNames, existingData.subgraphNames);
+            for (const fieldData of objectData.fieldDataByFieldName.values()) {
+                upsertFieldData(existingData.fieldDataByFieldName, fieldData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors);
+            }
+            return;
+        case graphql_1.Kind.UNION_TYPE_DEFINITION:
+            (0, utils_3.addMapEntries)(incomingData.memberByMemberTypeName, existingData.memberByMemberTypeName);
+            return;
+        default:
+            // Scalar type
+            return;
+    }
+}
+exports.upsertParentDefinitionData = upsertParentDefinitionData;
+function upsertObjectExtensionData(parentExtensionDataByTypeName, incomingData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors) {
+    const existingData = parentExtensionDataByTypeName.get(incomingData.name);
+    extractPersistedDirectives(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+    if (!existingData) {
+        incomingData.node = {
+            kind: incomingData.kind,
+            name: (0, utils_1.stringToNameNode)(incomingData.name),
+        };
+        for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+            fieldData.node = {
+                arguments: [],
+                directives: [],
+                kind: fieldData.node.kind,
+                name: (0, utils_1.stringToNameNode)(fieldData.name),
+                type: fieldData.type,
+            };
+            namedOutputTypeNames.add(fieldData.namedTypeName);
+            extractPersistedDirectives(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+            for (const inputValueData of fieldData.argumentDataByArgumentName.values()) {
+                inputValueData.node = {
+                    directives: [],
+                    kind: inputValueData.node.kind,
+                    name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                    type: inputValueData.type,
+                };
+                namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+                extractPersistedDirectives(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName);
+            }
+        }
+        parentExtensionDataByTypeName.set(incomingData.name, incomingData);
+        return;
+    }
+    (0, utils_3.addIterableValuesToSet)(incomingData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+    (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+    for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+        upsertFieldData(existingData.fieldDataByFieldName, fieldData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors);
+    }
+}
+exports.upsertObjectExtensionData = upsertObjectExtensionData;
+function upsertPersistedDirectivesData(existingData, incomingData) {
+    if (incomingData.isDeprecated && existingData.deprecatedReason.length < incomingData.deprecatedReason.length) {
+        existingData.isDeprecated = true;
+        existingData.deprecatedReason = incomingData.deprecatedReason;
+    }
+    for (const [directiveName, directiveNodes] of incomingData.directives) {
+        const existingDirectiveNodes = existingData.directives.get(directiveName);
+        if (!existingDirectiveNodes) {
+            existingData.directives.set(directiveName, directiveNodes);
+            continue;
+        }
+        existingDirectiveNodes.push(...directiveNodes);
+    }
+    for (const [tagName, tagDirectiveNode] of incomingData.tags) {
+        if (existingData.tags.has(tagName)) {
+            continue;
+        }
+        existingData.tags.set(tagName, tagDirectiveNode);
+    }
+}
+function pushAuthorizationDirectives(fieldData, authorizationData) {
+    if (!authorizationData) {
+        return;
+    }
+    const fieldAuthorizationData = authorizationData.fieldAuthorizationDataByFieldName.get(fieldData.name);
+    if (!fieldAuthorizationData) {
+        return;
+    }
+    if (fieldAuthorizationData.requiresAuthentication) {
+        fieldData.persistedDirectivesData.directives.set(string_constants_1.AUTHENTICATED, [(0, utils_3.generateSimpleDirective)(string_constants_1.AUTHENTICATED)]);
+    }
+    if (fieldAuthorizationData.requiredScopes.length > 0) {
+        fieldData.persistedDirectivesData.directives.set(string_constants_1.REQUIRES_SCOPES, [
+            (0, utils_3.generateRequiresScopesDirective)(fieldAuthorizationData.requiredScopes),
+        ]);
+    }
+}
+exports.pushAuthorizationDirectives = pushAuthorizationDirectives;
+function upsertValidObjectExtensionData(parentDefinitionDataByTypeName, incomingData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors, authorizationData) {
+    const existingData = parentDefinitionDataByTypeName.get(incomingData.name);
+    if (!existingData) {
+        if (incomingData.isRootType) {
+            for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+                pushAuthorizationDirectives(fieldData, authorizationData);
+            }
+            parentDefinitionDataByTypeName.set(incomingData.name, {
+                directivesByDirectiveName: incomingData.directivesByDirectiveName,
+                fieldDataByFieldName: incomingData.fieldDataByFieldName,
+                implementedInterfaceTypeNames: incomingData.implementedInterfaceTypeNames,
+                isRootType: true,
+                isEntity: false,
+                kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+                name: incomingData.name,
+                node: {
+                    kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+                    name: (0, utils_1.stringToNameNode)(incomingData.name),
+                },
+                persistedDirectivesData: incomingData.persistedDirectivesData,
+                renamedTypeName: incomingData.renamedTypeName,
+                subgraphNames: incomingData.subgraphNames,
+            });
+            return;
+        }
+        errors.push((0, errors_1.noBaseTypeExtensionError)(incomingData.name));
+        return;
+    }
+    if (existingData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+        throw (0, errors_1.incompatibleParentKindFatalError)(existingData.name, graphql_1.Kind.OBJECT_TYPE_DEFINITION, existingData.kind);
+    }
+    upsertPersistedDirectivesData(existingData.persistedDirectivesData, incomingData.persistedDirectivesData);
+    (0, utils_3.addIterableValuesToSet)(incomingData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+    for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+        upsertFieldData(existingData.fieldDataByFieldName, fieldData, persistedDirectiveDefinitionByDirectiveName, namedOutputTypeNames, namedInputValueTypeNames, errors);
+    }
+}
+exports.upsertValidObjectExtensionData = upsertValidObjectExtensionData;
+function generateDeprecatedDirective(reason) {
+    return {
+        kind: graphql_1.Kind.DIRECTIVE,
+        name: (0, utils_1.stringToNameNode)(string_constants_1.DEPRECATED),
+        arguments: [
+            {
+                kind: graphql_1.Kind.ARGUMENT,
+                name: (0, utils_1.stringToNameNode)(string_constants_1.REASON),
+                value: {
+                    kind: graphql_1.Kind.STRING,
+                    value: reason || string_constants_1.DEPRECATED_DEFAULT_ARGUMENT_VALUE, // use the default value if reason is empty
+                },
+            },
+        ],
+    };
+}
+function getValidFlattenedPersistedDirectiveNodeArray(directivesByDirectiveName, persistedDirectiveDefinitionByDirectiveName, hostPath, errors) {
+    const persistedDirectiveNodes = [];
+    for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
+        const persistedDirectiveDefinition = persistedDirectiveDefinitionByDirectiveName.get(directiveName);
+        if (!persistedDirectiveDefinition) {
+            continue;
+        }
+        if (directiveNodes.length < 2) {
+            persistedDirectiveNodes.push(...directiveNodes);
+            continue;
+        }
+        if (!persistedDirectiveDefinition.repeatable) {
+            errors.push((0, errors_1.invalidRepeatedFederatedDirectiveErrorMessage)(directiveName, hostPath));
+            continue;
+        }
+        persistedDirectiveNodes.push(...directiveNodes);
+    }
+    return persistedDirectiveNodes;
+}
+function getPersistedDirectiveNodes(nodeData, persistedDirectiveDefinitionByDirectiveName, errors) {
+    const persistedDirectiveNodes = [...nodeData.persistedDirectivesData.tags.values()];
+    if (nodeData.persistedDirectivesData.isDeprecated) {
+        persistedDirectiveNodes.push(generateDeprecatedDirective(nodeData.persistedDirectivesData.deprecatedReason));
+    }
+    persistedDirectiveNodes.push(...getValidFlattenedPersistedDirectiveNodeArray(nodeData.persistedDirectivesData.directives, persistedDirectiveDefinitionByDirectiveName, nodeData.name, errors));
+    return persistedDirectiveNodes;
+}
+function getNodeWithPersistedDirectivesByData(data, persistedDirectiveDefinitionByDirectiveName, errors) {
+    data.node.name = (0, utils_1.stringToNameNode)(data.name);
+    data.node.description = data.description;
+    data.node.directives = getPersistedDirectiveNodes(data, persistedDirectiveDefinitionByDirectiveName, errors);
+    return data.node;
+}
+exports.getNodeWithPersistedDirectivesByData = getNodeWithPersistedDirectivesByData;
+function getNodeWithPersistedDirectivesByFieldData(fieldData, persistedDirectiveDefinitionByDirectiveName, argumentNodes, errors) {
+    fieldData.node.arguments = argumentNodes;
+    fieldData.node.name = (0, utils_1.stringToNameNode)(fieldData.name);
+    fieldData.node.type = fieldData.type;
+    fieldData.node.description = fieldData.description;
+    fieldData.node.directives = getPersistedDirectiveNodes(fieldData, persistedDirectiveDefinitionByDirectiveName, errors);
+    return fieldData.node;
+}
+exports.getNodeWithPersistedDirectivesByFieldData = getNodeWithPersistedDirectivesByFieldData;
+function getNodeWithPersistedDirectivesByInputValueData(inputValueData, persistedDirectiveDefinitionByDirectiveName, errors) {
+    inputValueData.node.name = (0, utils_1.stringToNameNode)(inputValueData.name);
+    inputValueData.node.type = inputValueData.type;
+    inputValueData.node.description = inputValueData.description;
+    inputValueData.node.directives = getPersistedDirectiveNodes(inputValueData, persistedDirectiveDefinitionByDirectiveName, errors);
+    if (inputValueData.includeDefaultValue) {
+        inputValueData.node.defaultValue = inputValueData.defaultValue;
+    }
+    return inputValueData.node;
+}
+exports.getNodeWithPersistedDirectivesByInputValueData = getNodeWithPersistedDirectivesByInputValueData;
+function getValidFieldArgumentNodes(fieldData, persistedDirectiveDefinitionByDirectiveName, fieldConfigurationByFieldPath, errors) {
+    const argumentNodes = [];
+    const argumentNames = [];
+    const invalidRequiredArguments = [];
+    const fieldPath = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
+    for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
+        if (fieldData.subgraphNames.size === inputValueData.subgraphNames.size) {
+            argumentNames.push(argumentName);
+            argumentNodes.push(getNodeWithPersistedDirectivesByInputValueData(inputValueData, persistedDirectiveDefinitionByDirectiveName, errors));
+        }
+        else if (isTypeRequired(inputValueData.type)) {
+            invalidRequiredArguments.push({
+                inputValueName: argumentName,
+                missingSubgraphs: (0, utils_3.getEntriesNotInHashSet)(fieldData.subgraphNames, inputValueData.subgraphNames),
+                requiredSubgraphs: [...inputValueData.requiredSubgraphNames],
+            });
+        }
+    }
+    if (invalidRequiredArguments.length > 0) {
+        errors.push((0, errors_1.invalidRequiredInputValueError)(string_constants_1.FIELD, fieldPath, invalidRequiredArguments));
+    }
+    else if (argumentNames.length > 0) {
+        fieldConfigurationByFieldPath.set(fieldPath, {
+            argumentNames,
+            fieldName: fieldData.name,
+            typeName: fieldData.renamedParentTypeName,
+        });
+    }
+    return argumentNodes;
+}
+exports.getValidFieldArgumentNodes = getValidFieldArgumentNodes;
+function addValidatedArgumentNodes(argumentNodes, hostData, persistedDirectiveDefinitionByDirectiveName, errors, argumentNamesForFieldConfiguration) {
+    const invalidRequiredArgumentErrors = [];
+    for (const [argumentName, argumentData] of hostData.argumentDataByArgumentName) {
+        const missingSubgraphs = (0, utils_3.getEntriesNotInHashSet)(hostData.subgraphNames, argumentData.subgraphNames);
+        if (missingSubgraphs.length > 0) {
+            // Required arguments must be defined in all subgraphs that define the field
+            if (argumentData.requiredSubgraphNames.size > 0) {
+                invalidRequiredArgumentErrors.push({
+                    inputValueName: argumentName,
+                    missingSubgraphs,
+                    requiredSubgraphs: [...argumentData.requiredSubgraphNames],
+                });
+            }
+            /* If the argument is always optional, but it's not defined in all subgraphs that define the field,
+               the argument should not be included in the federated graph */
+            continue;
+        }
+        argumentNodes.push(getNodeWithPersistedDirectivesByInputValueData(argumentData, persistedDirectiveDefinitionByDirectiveName, errors));
+        if (argumentNamesForFieldConfiguration) {
+            argumentNamesForFieldConfiguration.add(argumentName);
+        }
+    }
+    if (invalidRequiredArgumentErrors.length > 0) {
+        errors.push((0, errors_1.invalidRequiredInputValueError)(string_constants_1.DIRECTIVE_DEFINITION, `@${hostData.name}`, invalidRequiredArgumentErrors));
+        return false;
+    }
+    return true;
+}
+function addValidPersistedDirectiveDefinitionNodeByData(definitions, data, persistedDirectiveDefinitionByDirectiveName, errors) {
+    const argumentNodes = [];
+    if (!addValidatedArgumentNodes(argumentNodes, data, persistedDirectiveDefinitionByDirectiveName, errors)) {
+        return;
+    }
+    definitions.push({
+        arguments: argumentNodes,
+        kind: graphql_1.Kind.DIRECTIVE_DEFINITION,
+        locations: (0, utils_1.setToNameNodeArray)(data.executableLocations),
+        name: (0, utils_1.stringToNameNode)(data.name),
+        repeatable: data.repeatable,
+        description: data.description,
+    });
+}
+exports.addValidPersistedDirectiveDefinitionNodeByData = addValidPersistedDirectiveDefinitionNodeByData;
+function isShareabilityOfAllFieldInstancesValid(fieldData) {
+    let shareableFields = 0;
+    let unshareableFields = 0;
+    for (const [subgraphName, isShareable] of fieldData.isShareableBySubgraphName) {
+        /*
+          shareability is ignored if:
+          1. the field is external
+          2. the field is overridden by another subgraph (in which case it has not been upserted)
+        */
+        if (fieldData.isExternalBySubgraphName.get(subgraphName)) {
+            continue;
+        }
+        if (isShareable) {
+            if (unshareableFields) {
+                return false;
+            }
+            shareableFields += 1;
+            continue;
+        }
+        unshareableFields += 1;
+        if (shareableFields || unshareableFields > 1) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isShareabilityOfAllFieldInstancesValid = isShareabilityOfAllFieldInstancesValid;
+function isFieldExternalInAllMutualSubgraphs(subgraphs, fieldData) {
+    const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(subgraphs, fieldData.subgraphNames);
+    if (mutualSubgraphs.size < 1) {
+        return false;
+    }
+    for (const mutualSubgraph of mutualSubgraphs) {
+        const isExternal = fieldData.isExternalBySubgraphName.get(mutualSubgraph);
+        if (isExternal) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+exports.isFieldExternalInAllMutualSubgraphs = isFieldExternalInAllMutualSubgraphs;
+var MergeMethod;
+(function (MergeMethod) {
+    MergeMethod[MergeMethod["UNION"] = 0] = "UNION";
+    MergeMethod[MergeMethod["INTERSECTION"] = 1] = "INTERSECTION";
+    MergeMethod[MergeMethod["CONSISTENT"] = 2] = "CONSISTENT";
+})(MergeMethod || (exports.MergeMethod = MergeMethod = {}));
+function isTypeValidImplementation(originalType, implementationType, concreteTypeNamesByAbstractTypeName) {
+    if (originalType.kind === graphql_1.Kind.NON_NULL_TYPE) {
+        if (implementationType.kind !== graphql_1.Kind.NON_NULL_TYPE) {
+            return false;
+        }
+        return isTypeValidImplementation(originalType.type, implementationType.type, concreteTypeNamesByAbstractTypeName);
+    }
+    if (implementationType.kind === graphql_1.Kind.NON_NULL_TYPE) {
+        return isTypeValidImplementation(originalType, implementationType.type, concreteTypeNamesByAbstractTypeName);
+    }
+    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 = concreteTypeNamesByAbstractTypeName.get(originalTypeName);
+                if (!concreteTypes) {
+                    return false;
+                }
+                return concreteTypes.has(implementationTypeName);
+            }
+            return false;
+        default:
+            if (implementationType.kind === graphql_1.Kind.LIST_TYPE) {
+                return isTypeValidImplementation(originalType.type, implementationType.type, concreteTypeNamesByAbstractTypeName);
+            }
+            return false;
+    }
+}
+exports.isTypeValidImplementation = isTypeValidImplementation;
 //# sourceMappingURL=utils.js.map