@wundergraph/composition 0.22.1 → 0.23.0

package/dist/federation/federation-factory.js

@@ -1,48 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.federateSubgraphs = exports.FederationFactory = void 0;
+exports.federateSubgraphsContract = exports.federateSubgraphsWithContracts = exports.federateSubgraphs = exports.FederationFactory = void 0;
 const graphql_1 = require("graphql");
 const ast_1 = require("../schema-building/ast");
 const utils_1 = require("../ast/utils");
 const errors_1 = require("../errors/errors");
+const utils_2 = require("./utils");
 const string_constants_1 = require("../utils/string-constants");
-const utils_2 = require("../utils/utils");
+const utils_3 = require("../utils/utils");
 const merge_1 = require("@graphql-tools/merge");
 const constants_1 = require("../utils/constants");
 const normalization_factory_1 = require("../normalization/normalization-factory");
-const utils_3 = require("../normalization/utils");
-const utils_4 = require("../schema-building/utils");
+const utils_4 = require("../normalization/utils");
+const utils_5 = require("../schema-building/utils");
 const walkers_1 = require("./walkers");
+const lodash_1 = require("lodash");
+const type_merging_1 = require("../schema-building/type-merging");
 class FederationFactory {
     authorizationDataByParentTypeName;
-    areFieldsExternal = false;
-    areFieldsShareable = false;
     concreteTypeNamesByAbstractTypeName;
-    fieldConfigurationByFieldPath = new Map();
-    namedInputValueTypeNames = new Set();
-    namedOutputTypeNames = new Set();
-    entityInterfaceFederationDataByTypeName;
-    executableDirectives = new Set();
-    parentTypeName = '';
-    persistedDirectiveDefinitions = new Set([string_constants_1.AUTHENTICATED, string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG, string_constants_1.REQUIRES_SCOPES]);
+    clientDefinitions = [constants_1.DEPRECATED_DEFINITION];
     currentSubgraphName = '';
-    childName = '';
     entityDataByTypeName;
+    entityInterfaceFederationDataByTypeName;
     errors = [];
     evaluatedObjectLikesBySubgraph = new Map();
+    fieldConfigurationByFieldPath = new Map();
     graph;
     graphEdges = new Set();
     graphPaths = new Map();
+    inaccessiblePaths = new Set();
+    internalSubgraphBySubgraphName;
     invalidOrScopesHostPaths = new Set();
-    isCurrentParentEntity = false;
-    isCurrentParentInterface = false;
-    isCurrentSubgraphVersionTwo = false;
-    isCurrentParentExtensionType = false;
-    isParentRootType = false;
-    isParentInputObject = false;
-    outputFieldTypeNames = new Set();
-    parentDefinitionDataByTypeName = new Map();
+    isVersionTwo = false;
+    namedInputValueTypeNames = new Set();
+    namedOutputTypeNames = new Set();
     objectExtensionDataByTypeName = new Map();
+    parentDefinitionDataByTypeName = new Map();
+    parentTagDataByTypeName = new Map();
+    pathsByNamedTypeName = new Map();
     persistedDirectiveDefinitionByDirectiveName = new Map([
         [string_constants_1.AUTHENTICATED, constants_1.AUTHENTICATED_DEFINITION],
         [string_constants_1.DEPRECATED, constants_1.DEPRECATED_DEFINITION],
@@ -50,9 +46,11 @@ class FederationFactory {
         [string_constants_1.REQUIRES_SCOPES, constants_1.REQUIRES_SCOPES_DEFINITION],
         [string_constants_1.TAG, constants_1.TAG_DEFINITION],
     ]);
-    rootTypeNames = new Set([string_constants_1.DEFAULT_MUTATION, string_constants_1.DEFAULT_QUERY, string_constants_1.DEFAULT_SUBSCRIPTION]);
-    internalSubgraphBySubgraphName;
+    persistedDirectiveDefinitions = new Set([string_constants_1.AUTHENTICATED, string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG, string_constants_1.REQUIRES_SCOPES]);
+    potentialPersistedDirectiveDefinitionDataByDirectiveName = new Map();
+    routerDefinitions = [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
     shareableErrorTypeNames = new Map();
+    tagNamesByPath = new Map();
     warnings;
     constructor(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainersByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings) {
         this.authorizationDataByParentTypeName = authorizationDataByParentTypeName;
@@ -68,13 +66,14 @@ class FederationFactory {
         if (data.implementedInterfaceTypeNames.size < 1) {
             return interfaces;
         }
+        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(data);
         const implementationErrorsMap = new Map();
         const invalidImplementationTypeStringByTypeName = new Map();
         for (const interfaceName of data.implementedInterfaceTypeNames) {
             interfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceName));
-            const implementationData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, interfaceName, string_constants_1.PARENT_DEFINITION_DATA);
+            const implementationData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, interfaceName, string_constants_1.PARENT_DEFINITION_DATA);
             if (implementationData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
-                invalidImplementationTypeStringByTypeName.set(implementationData.name, (0, utils_2.kindToTypeString)(implementationData.kind));
+                invalidImplementationTypeStringByTypeName.set(implementationData.name, (0, utils_3.kindToTypeString)(implementationData.kind));
                 continue;
             }
             const implementationErrors = {
@@ -93,11 +92,12 @@ class FederationFactory {
                 const invalidFieldImplementation = {
                     invalidAdditionalArguments: new Set(),
                     invalidImplementedArguments: [],
+                    isInaccessible: false,
                     originalResponseType: (0, merge_1.printTypeNode)(interfaceField.node.type),
                     unimplementedArguments: new Set(),
                 };
                 // The implemented field type must be equally or more restrictive than the original interface field type
-                if (!(0, utils_4.isTypeValidImplementation)(interfaceField.node.type, fieldData.node.type, this.concreteTypeNamesByAbstractTypeName)) {
+                if (!(0, utils_5.isTypeValidImplementation)(interfaceField.node.type, fieldData.node.type, this.concreteTypeNamesByAbstractTypeName)) {
                     hasErrors = true;
                     hasNestedErrors = true;
                     invalidFieldImplementation.implementedResponseType = (0, merge_1.printTypeNode)(fieldData.node.type);
@@ -136,6 +136,11 @@ class FederationFactory {
                     hasNestedErrors = true;
                     invalidFieldImplementation.invalidAdditionalArguments.add(argumentName);
                 }
+                if (!isParentInaccessible && fieldData.isInaccessible && !interfaceField.isInaccessible) {
+                    hasErrors = true;
+                    hasNestedErrors = true;
+                    invalidFieldImplementation.isInaccessible = true;
+                }
                 if (hasNestedErrors) {
                     implementationErrors.invalidFieldImplementations.set(fieldName, invalidFieldImplementation);
                 }
@@ -148,7 +153,7 @@ class FederationFactory {
             this.errors.push((0, errors_1.invalidImplementedTypeError)(data.name, invalidImplementationTypeStringByTypeName));
         }
         if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(data.node.name.value, (0, utils_2.kindToTypeString)(data.kind), implementationErrorsMap));
+            this.errors.push((0, errors_1.invalidInterfaceImplementationError)(data.node.name.value, (0, utils_3.kindToTypeString)(data.kind), implementationErrorsMap));
         }
         return interfaces;
     }
@@ -162,11 +167,11 @@ class FederationFactory {
                 return true;
             }
             if (entityAncestorName === parentTypeName) {
-                const hasOverlap = (0, utils_2.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_2.getOrThrowError)(this.entityDataByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
+                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityDataByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
                 this.graphPaths.set(path, hasOverlap);
                 return hasOverlap;
             }
-            if ((0, utils_2.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
+            if ((0, utils_3.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
                 this.graphPaths.set(path, true);
                 return true;
             }
@@ -185,7 +190,7 @@ class FederationFactory {
         return false;
     }
     updateEvaluatedSubgraphOccurrences(rootTypeFieldSubgraphs, objectSubgraphs, entityAncestors, parentTypeName) {
-        const mutualSubgraphs = (0, utils_2.getAllMutualEntries)(rootTypeFieldSubgraphs, objectSubgraphs);
+        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, objectSubgraphs);
         if (mutualSubgraphs.size > 0) {
             for (const mutualSubgraph of mutualSubgraphs) {
                 const evaluatedObjects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
@@ -198,9 +203,9 @@ class FederationFactory {
             }
         }
         for (const entityAncestorTypeName of entityAncestors) {
-            const entityObjectData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, entityAncestorTypeName, 'parentDefinitionDataByTypeName');
-            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_2.getAllMutualEntries)(rootTypeFieldSubgraphs, entityObjectData.subgraphNames);
-            const mutualEntityAncestorSubgraphsNames = (0, utils_2.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
+            const entityObjectData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, entityAncestorTypeName, 'parentDefinitionDataByTypeName');
+            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, entityObjectData.subgraphNames);
+            const mutualEntityAncestorSubgraphsNames = (0, utils_3.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
             for (const mutualSubgraphName of mutualEntityAncestorSubgraphsNames) {
                 const objects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraphName);
                 if (objects) {
@@ -222,6 +227,10 @@ class FederationFactory {
             return;
         }
         for (const [fieldName, fieldData] of objectData.fieldDataByFieldName) {
+            const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
+            if (this.inaccessiblePaths.has(fieldPath)) {
+                continue;
+            }
             const namedFieldTypeName = fieldData.namedTypeName;
             if (string_constants_1.ROOT_TYPES.has(namedFieldTypeName)) {
                 continue;
@@ -230,12 +239,12 @@ class FederationFactory {
             if (evaluatedObjectLikes.has(namedFieldTypeName)) {
                 continue;
             }
-            if ((0, utils_4.isFieldExternalInAllMutualSubgraphs)(rootTypeFieldData.subgraphs, fieldData)) {
+            if ((0, utils_5.isFieldExternalInAllMutualSubgraphs)(rootTypeFieldData.subgraphs, fieldData)) {
                 continue;
             }
             this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, objectData.subgraphNames, entityAncestors, parentTypeName);
             evaluatedObjectLikes.add(parentTypeName);
-            const isFieldResolvable = (0, utils_2.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
+            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
                 this.isFieldResolvableByEntityAncestor(entityAncestors, fieldData.subgraphNames, parentTypeName);
             const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
             const entity = this.entityDataByTypeName.get(namedFieldTypeName);
@@ -244,7 +253,7 @@ class FederationFactory {
                 if (constants_1.BASE_SCALARS.has(namedFieldTypeName)) {
                     continue;
                 }
-                const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
+                const namedTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, string_constants_1.PARENT_DEFINITION_DATA);
                 switch (namedTypeData.kind) {
                     case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     // intentional fallthrough
@@ -259,7 +268,7 @@ class FederationFactory {
                         this.evaluateResolvabilityOfAbstractType(namedFieldTypeName, namedTypeData.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, namedFieldTypeName] : [...entityAncestors]);
                         continue;
                     default:
-                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(namedTypeData.kind)));
                         continue;
                 }
             }
@@ -267,7 +276,7 @@ class FederationFactory {
                 this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath, parentTypeName));
                 continue;
             }
-            const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
+            const namedTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
             switch (namedTypeData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                 // intentional fallthrough
@@ -282,7 +291,7 @@ class FederationFactory {
                     this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
                     continue;
                 default:
-                    this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
+                    this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(namedTypeData.kind)));
             }
         }
     }
@@ -293,19 +302,19 @@ class FederationFactory {
         evaluatedObjectLikes.add(abstractTypeName);
         const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
         if (!concreteTypeNames) {
-            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_2.kindToTypeString)(abstractKind), abstractTypeName);
+            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(abstractKind), abstractTypeName);
             return;
         }
         for (const concreteTypeName of concreteTypeNames) {
             if (evaluatedObjectLikes.has(concreteTypeName)) {
                 continue;
             }
-            const concreteTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, 'parentDefinitionDataByTypeName');
+            const concreteTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, 'parentDefinitionDataByTypeName');
             if (concreteTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_2.kindToTypeString)(concreteTypeData.kind));
+                throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_3.kindToTypeString)(concreteTypeData.kind));
             }
             // If the concrete type is unreachable through an inline fragment, it is not an error
-            if (!(0, utils_2.doSetsHaveAnyOverlap)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
+            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
                 continue;
             }
             const entity = this.entityDataByTypeName.get(concreteTypeName);
@@ -316,7 +325,7 @@ class FederationFactory {
         if (!entityData) {
             return;
         }
-        const internalSubgraph = (0, utils_2.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
+        const internalSubgraph = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
         const parentDefinitionDataByTypeName = internalSubgraph.parentDefinitionDataByTypeName;
         const parentExtensionDataByTypeName = internalSubgraph.parentExtensionDataByTypeName;
         const objectData = parentDefinitionDataByTypeName.get(entityData.typeName) || parentExtensionDataByTypeName.get(entityData.typeName);
@@ -324,7 +333,7 @@ class FederationFactory {
             (objectData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION && objectData.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION)) {
             throw (0, errors_1.incompatibleParentKindFatalError)(entityData.typeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, objectData?.kind || graphql_1.Kind.NULL);
         }
-        const configurationData = (0, utils_2.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityData.typeName, 'internalSubgraph.configurationDataMap');
+        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityData.typeName, 'internalSubgraph.configurationDataMap');
         const keyFieldNames = new Set();
         const implicitKeys = [];
         // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
@@ -430,10 +439,10 @@ class FederationFactory {
                 continue;
             }
             // Add any top-level fields that compose the key in case they are external
-            (0, utils_2.addIterableValuesToSet)(keyFieldNames, configurationData.fieldNames);
+            (0, utils_3.addIterableValuesToSet)(keyFieldNames, configurationData.fieldNames);
             implicitKeys.push({
                 fieldName: '',
-                selectionSet: (0, utils_3.getNormalizedFieldSet)(documentNode),
+                selectionSet: (0, utils_4.getNormalizedFieldSet)(documentNode),
                 disableEntityResolver: true,
             });
         }
@@ -457,27 +466,599 @@ class FederationFactory {
     getEnumValueMergeMethod(enumTypeName) {
         if (this.namedInputValueTypeNames.has(enumTypeName)) {
             if (this.namedOutputTypeNames.has(enumTypeName)) {
-                return utils_4.MergeMethod.CONSISTENT;
+                return utils_5.MergeMethod.CONSISTENT;
             }
-            return utils_4.MergeMethod.INTERSECTION;
+            return utils_5.MergeMethod.INTERSECTION;
         }
-        return utils_4.MergeMethod.UNION;
+        return utils_5.MergeMethod.UNION;
     }
-    federate() {
-        const persistedDirectiveDefinitionDataByDirectiveName = new Map();
-        let shouldSkipPersistedExecutableDirectives = false;
+    generateTagData() {
+        for (const [path, tagNames] of this.tagNamesByPath) {
+            const paths = path.split('.');
+            if (paths.length < 1) {
+                continue;
+            }
+            const parentTagData = (0, utils_3.getValueOrDefault)(this.parentTagDataByTypeName, paths[0], () => (0, utils_2.newParentTagData)(paths[0]));
+            switch (paths.length) {
+                // parent type
+                case 1:
+                    for (const tagName of tagNames) {
+                        parentTagData.tagNames.add(tagName);
+                    }
+                    break;
+                // child type
+                case 2:
+                    const childTagData = (0, utils_3.getValueOrDefault)(parentTagData.childTagDataByChildName, paths[1], () => (0, utils_2.newChildTagData)(paths[1]));
+                    for (const tagName of tagNames) {
+                        childTagData.tagNames.add(tagName);
+                    }
+                    break;
+                // field argument
+                case 3:
+                    const fieldTagData = (0, utils_3.getValueOrDefault)(parentTagData.childTagDataByChildName, paths[1], () => (0, utils_2.newChildTagData)(paths[1]));
+                    const argumentTagData = (0, utils_3.getValueOrDefault)(fieldTagData.tagNamesByArgumentName, paths[2], () => new Set());
+                    for (const tagName of tagNames) {
+                        argumentTagData.add(tagName);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    evaluateRootNodeFieldsResolvability() {
+        for (const rootTypeName of string_constants_1.ROOT_TYPES) {
+            const rootTypeData = this.parentDefinitionDataByTypeName.get(rootTypeName);
+            if (!rootTypeData || rootTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                continue;
+            }
+            // After evaluating all of a root type's fields, break and return if there are errors
+            if (this.errors.length > 0) {
+                break;
+            }
+            // If a root type field returns a Scalar or Enum, track it so that it is not evaluated it again
+            const evaluatedRootScalarsAndEnums = new Set(constants_1.BASE_SCALARS);
+            for (const [rootTypeFieldName, fieldData] of rootTypeData.fieldDataByFieldName) {
+                const namedRootFieldTypeName = fieldData.namedTypeName;
+                if (evaluatedRootScalarsAndEnums.has(namedRootFieldTypeName)) {
+                    continue;
+                }
+                if (!this.shouldEvaluateObjectLike(fieldData.subgraphNames, namedRootFieldTypeName)) {
+                    continue;
+                }
+                const namedTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, namedRootFieldTypeName, 'parentDefinitionDataByTypeName');
+                const fieldPath = `${rootTypeName}.${rootTypeFieldName}`;
+                if (this.inaccessiblePaths.has(fieldPath)) {
+                    continue;
+                }
+                const rootTypeFieldData = {
+                    fieldName: rootTypeFieldName,
+                    fieldTypeNodeString: (0, merge_1.printTypeNode)(fieldData.node.type),
+                    path: fieldPath,
+                    typeName: rootTypeName,
+                    subgraphs: fieldData.subgraphNames,
+                };
+                switch (namedTypeData.kind) {
+                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                        // Root type fields whose response type is an Enums and Scalars will always be resolvable
+                        // Consequently, subsequent checks can be skipped
+                        evaluatedRootScalarsAndEnums.add(namedRootFieldTypeName);
+                        continue;
+                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfObject(namedTypeData, rootTypeFieldData, fieldPath, new Set(), this.entityDataByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
+                        continue;
+                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                    // intentional fallthrough
+                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                        this.evaluateResolvabilityOfAbstractType(namedRootFieldTypeName, namedTypeData.kind, rootTypeFieldData, fieldPath, new Set(), this.entityDataByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
+                        continue;
+                    default:
+                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_3.kindToTypeString)(namedTypeData.kind)));
+                }
+            }
+        }
+    }
+    upsertEnumValueData(enumValueDataByValueName, incomingData) {
+        const existingData = enumValueDataByValueName.get(incomingData.name);
+        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.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;
+        (0, utils_5.setLongestDescription)(existingData, incomingData);
+    }
+    upsertInputValueData(inputValueDataByValueName, incomingData) {
+        const existingData = inputValueDataByValueName.get(incomingData.name);
+        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.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;
+        }
+        (0, utils_5.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, this.errors);
+        if (typeNode) {
+            existingData.type = typeNode;
+        }
+        else {
+            if (!typeErrors || typeErrors.length < 2) {
+                throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+            }
+            existingData.isArgument
+                ? this.errors.push((0, errors_1.incompatibleArgumentTypesError)(existingData.name, existingData.renamedPath, typeErrors[0], typeErrors[1]))
+                : this.errors.push((0, errors_1.incompatibleChildTypesError)(existingData.renamedPath, typeErrors[0], typeErrors[1]));
+        }
+        (0, utils_5.compareAndValidateInputValueDefaultValues)(existingData, incomingData, this.errors);
+    }
+    handleArgumentInaccessibility(isParentInaccessible, inputValueData, argumentPath, fieldPath) {
+        /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
+         ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
+         ** error. */
+        if (isParentInaccessible) {
+            this.inaccessiblePaths.add(argumentPath);
+            return;
+        }
+        if (!(0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+            return;
+        }
+        if ((0, utils_5.isTypeRequired)(inputValueData.type)) {
+            this.errors.push((0, errors_1.inaccessibleRequiredArgumentError)(inputValueData.name, argumentPath, fieldPath));
+        }
+        else {
+            this.inaccessiblePaths.add(argumentPath);
+        }
+    }
+    upsertFieldData(fieldDataByFieldName, incomingData, isParentInaccessible) {
+        const fieldPath = `${incomingData.renamedParentTypeName}.${incomingData.name}`;
+        (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(fieldPath);
+        this.namedOutputTypeNames.add(incomingData.namedTypeName);
+        const existingData = fieldDataByFieldName.get(incomingData.name);
+        (0, utils_5.extractPersistedDirectives)(existingData?.persistedDirectivesData || incomingData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
+        if (isParentInaccessible || isFieldInaccessible) {
+            this.inaccessiblePaths.add(fieldPath);
+        }
+        if (incomingData.persistedDirectivesData.tags.size > 0) {
+            const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, fieldPath, () => new Set());
+            for (const tagName of incomingData.persistedDirectivesData.tags.keys()) {
+                tagNames.add(tagName);
+            }
+        }
+        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 [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
+                inputValueData.node = {
+                    directives: [],
+                    kind: inputValueData.node.kind,
+                    name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                    type: inputValueData.type,
+                };
+                const argumentPath = `${fieldPath}(${argumentName}: ... )`;
+                const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+                (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                this.namedInputValueTypeNames.add(namedArgumentTypeName);
+                (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
+                 ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
+                 ** error. */
+                this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+                if (inputValueData.persistedDirectivesData.tags.size > 0) {
+                    const tagArgumentPath = `${fieldPath}.${argumentName}`;
+                    const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, tagArgumentPath, () => new Set());
+                    for (const tagName of inputValueData.persistedDirectivesData.tags.keys()) {
+                        tagNames.add(tagName);
+                    }
+                }
+            }
+            return;
+        }
+        const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingData.type, incomingData.type, fieldPath, this.errors);
+        if (typeNode) {
+            existingData.type = typeNode;
+        }
+        else {
+            if (!typeErrors || typeErrors.length < 2) {
+                throw (0, errors_1.fieldTypeMergeFatalError)(existingData.name);
+            }
+            this.errors.push((0, errors_1.incompatibleChildTypesError)(fieldPath, typeErrors[0], typeErrors[1]));
+        }
+        for (const [argumentName, inputValueData] of incomingData.argumentDataByArgumentName) {
+            const argumentPath = `${fieldPath}(${argumentName}: ... )`;
+            const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+            this.namedInputValueTypeNames.add(namedArgumentTypeName);
+            /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
+             ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
+             ** error. */
+            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+            if (inputValueData.persistedDirectivesData.tags.size > 0) {
+                const tagArgumentPath = `${fieldPath}.${argumentName}`;
+                const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, tagArgumentPath, () => new Set());
+                for (const tagName of inputValueData.persistedDirectivesData.tags.keys()) {
+                    tagNames.add(tagName);
+                }
+            }
+            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData);
+        }
+        (0, utils_5.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);
+    }
+    getClientSchemaUnionMembers(unionData) {
+        const members = [];
+        for (const [memberName, namedTypeNode] of unionData.memberByMemberTypeName) {
+            if (!this.inaccessiblePaths.has(memberName)) {
+                members.push(namedTypeNode);
+            }
+        }
+        return members;
+    }
+    upsertParentDefinitionData(incomingData, subgraphName) {
+        const entityInterfaceData = this.entityInterfaceFederationDataByTypeName.get(incomingData.name);
+        const existingData = this.parentDefinitionDataByTypeName.get(incomingData.name);
+        const baseData = existingData || incomingData;
+        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(baseData);
+        if (isParentInaccessible) {
+            this.inaccessiblePaths.add(incomingData.name);
+        }
+        if (incomingData.persistedDirectivesData.tags.size > 0) {
+            const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, incomingData.name, () => new Set());
+            for (const tagName of incomingData.persistedDirectivesData.tags.keys()) {
+                tagNames.add(tagName);
+            }
+        }
+        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),
+            };
+            this.parentDefinitionDataByTypeName.set(incomingData.name, incomingData);
+            switch (incomingData.kind) {
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                    for (const [enumValueName, enumValueData] of incomingData.enumValueDataByValueName) {
+                        enumValueData.node = {
+                            directives: [],
+                            kind: enumValueData.node.kind,
+                            name: (0, utils_1.stringToNameNode)(enumValueData.name),
+                        };
+                        (0, utils_5.extractPersistedDirectives)(enumValueData.persistedDirectivesData, enumValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        if ((0, utils_5.isNodeDataInaccessible)(enumValueData)) {
+                            this.inaccessiblePaths.add(`${incomingData.name}.${enumValueName}`);
+                        }
+                    }
+                    return;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    for (const [inputFieldName, inputValueData] of incomingData.inputValueDataByValueName) {
+                        inputValueData.node = {
+                            directives: [],
+                            kind: inputValueData.node.kind,
+                            name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                            type: inputValueData.type,
+                        };
+                        const namedInputFieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+                        const inputFieldPath = `${incomingData.name}.${inputFieldName}`;
+                        (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputFieldPath);
+                        this.namedInputValueTypeNames.add(namedInputFieldTypeName);
+                        (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+                            this.inaccessiblePaths.add(inputFieldPath);
+                        }
+                    }
+                    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,
+                        };
+                        const fieldPath = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
+                        (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
+                        this.namedOutputTypeNames.add(fieldData.namedTypeName);
+                        (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                        const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(fieldData);
+                        if (isParentInaccessible || isFieldInaccessible) {
+                            this.inaccessiblePaths.add(fieldPath);
+                        }
+                        for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
+                            inputValueData.node = {
+                                directives: [],
+                                kind: inputValueData.node.kind,
+                                name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                                type: inputValueData.type,
+                            };
+                            const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+                            const argumentPath = `${fieldPath}(${argumentName}: ... )`;
+                            (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                            this.namedInputValueTypeNames.add(namedArgumentTypeName);
+                            (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                            /* If either the parent or the field to which the field belongs are declared inaccessible, the nullability
+                             ** of the argument is not considered. However, if only the argument is declared inaccessible, it is an
+                             ** error. */
+                            this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+                        }
+                    }
+                    return;
+                default:
+                    // Scalar and Union
+                    return;
+            }
+        }
+        (0, utils_5.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) {
+                this.errors.push((0, errors_1.incompatibleParentKindMergeError)(existingData.name, (0, utils_3.kindToTypeString)(existingData.kind), (0, utils_3.kindToTypeString)(incomingData.kind)));
+                return;
+            }
+        }
+        switch (existingData.kind) {
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                existingData.appearances += 1;
+                for (const data of incomingData.enumValueDataByValueName.values()) {
+                    this.upsertEnumValueData(existingData.enumValueDataByValueName, data);
+                }
+                return;
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                if (isParentInaccessible && !existingData.isInaccessible) {
+                    this.propagateInaccessibilityToExistingChildren(existingData);
+                }
+                (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+                for (const [inputFieldName, inputValueData] of incomingData
+                    .inputValueDataByValueName) {
+                    const inputFieldPath = `${incomingData.name}.${inputFieldName}`;
+                    const namedInputFieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+                    (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedInputFieldTypeName, () => new Set()).add(inputFieldPath);
+                    this.namedInputValueTypeNames.add(namedInputFieldTypeName);
+                    this.upsertInputValueData(existingData.inputValueDataByValueName, inputValueData);
+                    if (isParentInaccessible || (0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+                        this.inaccessiblePaths.add(inputFieldPath);
+                    }
+                }
+                return;
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            // intentional fallthrough
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                if (isParentInaccessible && !existingData.isInaccessible) {
+                    this.propagateInaccessibilityToExistingChildren(existingData);
+                }
+                const objectData = incomingData;
+                if (objectData.persistedDirectivesData.tags.size > 0) {
+                    const tagNames = (0, utils_3.getValueOrDefault)(this.tagNamesByPath, incomingData.name, () => new Set());
+                    for (const tagName of objectData.persistedDirectivesData.tags.keys()) {
+                        tagNames.add(tagName);
+                    }
+                }
+                (0, utils_3.addIterableValuesToSet)(objectData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+                (0, utils_3.addIterableValuesToSet)(objectData.subgraphNames, existingData.subgraphNames);
+                for (const fieldData of objectData.fieldDataByFieldName.values()) {
+                    this.upsertFieldData(existingData.fieldDataByFieldName, fieldData, isParentInaccessible || existingData.isInaccessible);
+                }
+                return;
+            case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                (0, utils_3.addMapEntries)(incomingData.memberByMemberTypeName, existingData.memberByMemberTypeName);
+                return;
+            default:
+                // Scalar type
+                return;
+        }
+    }
+    upsertObjectExtensionData(incomingData) {
+        const existingData = this.objectExtensionDataByTypeName.get(incomingData.name);
+        const baseData = existingData || incomingData;
+        (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(baseData);
+        if (isParentInaccessible) {
+            this.inaccessiblePaths.add(incomingData.name);
+        }
+        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,
+                };
+                const fieldPath = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
+                (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
+                this.namedOutputTypeNames.add(fieldData.namedTypeName);
+                (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(fieldData);
+                if (isParentInaccessible || isFieldInaccessible) {
+                    this.inaccessiblePaths.add(fieldPath);
+                }
+                for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
+                    inputValueData.node = {
+                        directives: [],
+                        kind: inputValueData.node.kind,
+                        name: (0, utils_1.stringToNameNode)(inputValueData.name),
+                        type: inputValueData.type,
+                    };
+                    const namedArgumentTypeName = (0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type);
+                    const argumentPath = `${fieldPath}(${argumentName}: ... )`;
+                    (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, namedArgumentTypeName, () => new Set()).add(argumentPath);
+                    this.namedInputValueTypeNames.add(namedArgumentTypeName);
+                    (0, utils_5.extractPersistedDirectives)(inputValueData.persistedDirectivesData, inputValueData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
+                    this.handleArgumentInaccessibility(isParentInaccessible || isFieldInaccessible, inputValueData, argumentPath, fieldPath);
+                }
+            }
+            this.objectExtensionDataByTypeName.set(incomingData.name, incomingData);
+            return;
+        }
+        if (isParentInaccessible && !existingData.isInaccessible) {
+            this.propagateInaccessibilityToExistingChildren(existingData);
+        }
+        (0, utils_3.addIterableValuesToSet)(incomingData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+        (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+        for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+            this.upsertFieldData(existingData.fieldDataByFieldName, fieldData, isParentInaccessible);
+        }
+    }
+    propagateInaccessibilityToExistingChildren(data) {
+        data.isInaccessible = true;
+        switch (data.kind) {
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                for (const inputFieldName of data.inputValueDataByValueName.keys()) {
+                    this.inaccessiblePaths.add(`${data.name}.${inputFieldName}`);
+                }
+                break;
+            default:
+                for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
+                    const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
+                    this.inaccessiblePaths.add(fieldPath);
+                    for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
+                        const argumentPath = `${fieldPath}(${argumentName}: ... )`;
+                        this.inaccessiblePaths.add(argumentPath);
+                    }
+                }
+        }
+    }
+    upsertValidObjectExtensionData(incomingData) {
+        const isParentInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
+        const existingData = this.parentDefinitionDataByTypeName.get(incomingData.name);
+        if (!existingData) {
+            if (incomingData.isRootType) {
+                const authorizationData = this.authorizationDataByParentTypeName.get(incomingData.name);
+                for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+                    (0, utils_5.pushAuthorizationDirectives)(fieldData, authorizationData);
+                }
+                this.parentDefinitionDataByTypeName.set(incomingData.name, {
+                    directivesByDirectiveName: incomingData.directivesByDirectiveName,
+                    fieldDataByFieldName: incomingData.fieldDataByFieldName,
+                    implementedInterfaceTypeNames: incomingData.implementedInterfaceTypeNames,
+                    isRootType: true,
+                    isInaccessible: isParentInaccessible,
+                    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;
+            }
+            this.errors.push((0, errors_1.noBaseTypeExtensionError)(incomingData.name));
+            return;
+        }
+        if (existingData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            this.errors.push((0, errors_1.incompatibleObjectExtensionOrphanBaseTypeError)(existingData.name, (0, utils_3.kindToTypeString)(existingData.kind)));
+            return;
+        }
+        (0, utils_5.upsertPersistedDirectivesData)(existingData.persistedDirectivesData, incomingData.persistedDirectivesData);
+        if (isParentInaccessible) {
+            this.inaccessiblePaths.add(incomingData.name);
+            // If the type was not previously known to be inaccessible, the existing children and arguments must be updated
+            if (!existingData.isInaccessible) {
+                this.propagateInaccessibilityToExistingChildren(existingData);
+            }
+        }
+        (0, utils_3.addIterableValuesToSet)(incomingData.implementedInterfaceTypeNames, existingData.implementedInterfaceTypeNames);
+        for (const fieldData of incomingData.fieldDataByFieldName.values()) {
+            this.upsertFieldData(existingData.fieldDataByFieldName, fieldData, isParentInaccessible);
+        }
+    }
+    upsertPersistedDirectiveDefinitionData(incomingData, subgraphNumber) {
+        const name = incomingData.name;
+        const existingData = this.potentialPersistedDirectiveDefinitionDataByDirectiveName.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()) {
+                this.namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+                this.upsertInputValueData(argumentDataByArgumentName, inputValueData);
+            }
+            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.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) {
+            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.delete(name);
+            return;
+        }
+        (0, utils_5.setMutualExecutableLocations)(existingData, incomingData.executableLocations);
+        // If there are no mutually defined executable locations, the definition should not be persisted
+        if (existingData.executableLocations.size < 1) {
+            this.potentialPersistedDirectiveDefinitionDataByDirectiveName.delete(name);
+            return;
+        }
+        for (const inputValueData of incomingData.argumentDataByArgumentName.values()) {
+            this.namedInputValueTypeNames.add((0, ast_1.getTypeNodeNamedTypeName)(inputValueData.type));
+            this.upsertInputValueData(existingData.argumentDataByArgumentName, inputValueData);
+        }
+        (0, utils_5.setLongestDescription)(existingData, incomingData);
+        existingData.repeatable &&= incomingData.repeatable;
+        (0, utils_3.addIterableValuesToSet)(incomingData.subgraphNames, existingData.subgraphNames);
+    }
+    /* federateInternalSubgraphData is responsible for merging each subgraph TypeScript representation of a GraphQL type
+     ** into a single representation.
+     ** This method is always necessary, regardless of whether federating a source graph or contract graph. */
+    federateInternalSubgraphData() {
         let subgraphNumber = 0;
-        let isVersionTwo = false;
+        let shouldSkipPersistedExecutableDirectives = false;
         for (const internalSubgraph of this.internalSubgraphBySubgraphName.values()) {
             subgraphNumber += 1;
             this.currentSubgraphName = internalSubgraph.name;
-            isVersionTwo ||= internalSubgraph.isVersionTwo;
+            this.isVersionTwo ||= internalSubgraph.isVersionTwo;
             (0, walkers_1.createMultiGraphAndRenameRootTypes)(this, internalSubgraph);
             for (const parentDefinitionData of internalSubgraph.parentDefinitionDataByTypeName.values()) {
-                (0, utils_4.upsertParentDefinitionData)(this.parentDefinitionDataByTypeName, parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.entityInterfaceFederationDataByTypeName, this.namedOutputTypeNames, this.namedInputValueTypeNames, internalSubgraph.name, this.errors);
+                this.upsertParentDefinitionData(parentDefinitionData, internalSubgraph.name);
             }
             for (const objectExtensionData of internalSubgraph.parentExtensionDataByTypeName.values()) {
-                (0, utils_4.upsertObjectExtensionData)(this.objectExtensionDataByTypeName, objectExtensionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedOutputTypeNames, this.namedInputValueTypeNames, this.errors);
+                this.upsertObjectExtensionData(objectExtensionData);
             }
             if (shouldSkipPersistedExecutableDirectives) {
                 continue;
@@ -489,41 +1070,30 @@ class FederationFactory {
                 continue;
             }
             for (const persistedDirectiveDefinitionData of internalSubgraph.persistedDirectiveDefinitionDataByDirectiveName.values()) {
-                (0, utils_4.upsertPersistedDirectiveDefinitionData)(persistedDirectiveDefinitionDataByDirectiveName, persistedDirectiveDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedInputValueTypeNames, subgraphNumber, this.errors);
+                this.upsertPersistedDirectiveDefinitionData(persistedDirectiveDefinitionData, subgraphNumber);
             }
-            /* Invalid directives keys are deleted; if there are no entries left, it is no longer necessary to evaluate more
+            /* Invalid directive keys are deleted; if there are no entries left, it is no longer necessary to evaluate more
                executable directives. */
-            if (!persistedDirectiveDefinitionDataByDirectiveName.size) {
+            if (this.potentialPersistedDirectiveDefinitionDataByDirectiveName.size < 1) {
                 shouldSkipPersistedExecutableDirectives = true;
             }
         }
-        const definitions = isVersionTwo
-            ? [
-                constants_1.AUTHENTICATED_DEFINITION,
-                constants_1.DEPRECATED_DEFINITION,
-                constants_1.INACCESSIBLE_DEFINITION,
-                constants_1.REQUIRES_SCOPES_DEFINITION,
-                constants_1.TAG_DEFINITION,
-                constants_1.SCOPE_SCALAR_DEFINITION,
-            ]
-            : [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
-        for (const data of persistedDirectiveDefinitionDataByDirectiveName.values()) {
-            (0, utils_4.addValidPersistedDirectiveDefinitionNodeByData)(definitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
-        }
+    }
+    handleEntityInterfaces() {
         for (const [typeName, entityInterfaceData] of this.entityInterfaceFederationDataByTypeName) {
-            (0, utils_2.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
-            const entityInterface = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, 'parentDefinitionDataByTypeName');
+            (0, utils_3.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
+            const entityInterface = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, string_constants_1.PARENT_DEFINITION_DATA);
             if (entityInterface.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 // TODO error
                 continue;
             }
             for (const subgraphName of entityInterfaceData.interfaceObjectSubgraphs) {
-                const configurationDataMap = (0, utils_2.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataByParentTypeName;
+                const configurationDataMap = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataByParentTypeName;
                 const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(typeName);
                 if (!concreteTypeNames) {
                     continue;
                 }
-                const interfaceObjectConfiguration = (0, utils_2.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
+                const interfaceObjectConfiguration = (0, utils_3.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
                 const keys = interfaceObjectConfiguration.keys;
                 if (!keys) {
                     // TODO no keys error
@@ -538,14 +1108,14 @@ class FederationFactory {
                         continue;
                     }
                     if (authorizationData) {
-                        const concreteAuthorizationData = (0, utils_2.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_2.newAuthorizationData)(concreteTypeName));
+                        const concreteAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, concreteTypeName, () => (0, utils_3.newAuthorizationData)(concreteTypeName));
                         for (const fieldAuthorizationData of authorizationData.fieldAuthorizationDataByFieldName.values()) {
-                            if (!(0, utils_2.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, fieldAuthorizationData)) {
+                            if (!(0, utils_3.upsertFieldAuthorizationData)(concreteAuthorizationData.fieldAuthorizationDataByFieldName, fieldAuthorizationData)) {
                                 this.invalidOrScopesHostPaths.add(`${concreteTypeName}.${fieldAuthorizationData.fieldName}`);
                             }
                         }
                     }
-                    const concreteTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, 'parentDefinitionDataByTypeName');
+                    const concreteTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, concreteTypeName, string_constants_1.PARENT_DEFINITION_DATA);
                     if (concreteTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                         continue;
                     }
@@ -567,103 +1137,89 @@ class FederationFactory {
                             // TODO handle shareability
                             continue;
                         }
-                        const interfaceFieldData = (0, utils_2.getOrThrowError)(entityInterface.fieldDataByFieldName, fieldName, `${typeName}.fieldDataByFieldName`);
+                        const interfaceFieldData = (0, utils_3.getOrThrowError)(entityInterface.fieldDataByFieldName, fieldName, `${typeName}.fieldDataByFieldName`);
                         concreteTypeData.fieldDataByFieldName.set(fieldName, { ...interfaceFieldData });
                     }
                     configurationDataMap.set(concreteTypeName, configurationData);
                 }
             }
         }
-        if (this.invalidOrScopesHostPaths.size > 0) {
-            this.errors.push((0, errors_1.orScopesLimitError)(utils_2.maxOrScopes, [...this.invalidOrScopesHostPaths]));
-        }
-        for (const [parentTypeName, objectExtensionData] of this.objectExtensionDataByTypeName) {
-            (0, utils_4.upsertValidObjectExtensionData)(this.parentDefinitionDataByTypeName, objectExtensionData, this.persistedDirectiveDefinitionByDirectiveName, this.namedOutputTypeNames, this.namedInputValueTypeNames, this.errors, this.authorizationDataByParentTypeName.get(parentTypeName));
-        }
-        // for (const [typeName, extension] of this.extensions) {
-        //   this.parentTypeName = typeName;
-        //   if (extension.isRootType && !this.parents.has(typeName)) {
-        //     this.upsertParentNode(objectTypeExtensionNodeToMutableDefinitionNode(extension.node));
-        //   }
-        //   const baseObject = this.parents.get(typeName);
-        //   if (!baseObject) {
-        //     this.errors.push(noBaseTypeExtensionError(typeName));
-        //     continue;
-        //   }
-        //
-        //   if (baseObject.kind !== Kind.OBJECT_TYPE_DEFINITION) {
-        //     throw incompatibleParentKindFatalError(typeName, Kind.OBJECT_TYPE_DEFINITION, baseObject.kind);
-        //   }
-        //   this.upsertExtensionPersistedDirectives(extension.directives, baseObject.directives);
-        //   for (const [extensionFieldName, extensionFieldContainer] of extension.fields) {
-        //     const baseFieldContainer = baseObject.fields.get(extensionFieldName);
-        //     if (!baseFieldContainer) {
-        //       baseObject.fields.set(extensionFieldName, extensionFieldContainer);
-        //       continue;
-        //     }
-        //     if (baseFieldContainer.isShareable && extensionFieldContainer.isShareable) {
-        //       this.childName = extensionFieldName;
-        //       this.upsertExtensionFieldArguments(extensionFieldContainer.arguments, baseFieldContainer.arguments);
-        //       addIterableValuesToSet(extensionFieldContainer.subgraphNames, baseFieldContainer.subgraphNames);
-        //       continue;
-        //     }
-        //     const parent = this.shareableErrorTypeNames.get(typeName);
-        //     if (parent) {
-        //       parent.add(extensionFieldName);
-        //       continue;
-        //     }
-        //     this.shareableErrorTypeNames.set(typeName, new Set<string>([extensionFieldName]));
-        //   }
-        //   for (const interfaceName of extension.interfaces) {
-        //     baseObject.interfaces.add(interfaceName);
-        //   }
-        // }
-        // for (const [parentTypeName, children] of this.shareableErrorTypeNames) {
-        //   const parent = getOrThrowError(this.parents, parentTypeName, PARENTS);
-        //   if (parent.kind !== Kind.OBJECT_TYPE_DEFINITION) {
-        //     throw incompatibleParentKindFatalError(parentTypeName, Kind.OBJECT_TYPE_DEFINITION, parent.kind);
-        //   }
-        //   this.errors.push(shareableFieldDefinitionsError(parent, children));
-        // }
-        const definitionsWithInterfaces = [];
+    }
+    pushParentDefinitionDataToDocumentDefinitions(interfaceImplementations) {
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
             switch (parentDefinitionData.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     const enumValueNodes = [];
+                    const clientEnumValueNodes = [];
                     const mergeMethod = this.getEnumValueMergeMethod(parentTypeName);
                     for (const enumValueData of parentDefinitionData.enumValueDataByValueName.values()) {
-                        const enumValueNode = (0, utils_4.getNodeWithPersistedDirectivesByData)(enumValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
+                        const enumValueNode = (0, utils_5.getNodeForRouterSchemaByData)(enumValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
+                        const isValueInaccessible = (0, utils_5.isNodeDataInaccessible)(enumValueData);
+                        const clientEnumValueNode = {
+                            ...enumValueData.node,
+                            directives: (0, utils_5.getClientPersistedDirectiveNodes)(enumValueData),
+                        };
                         switch (mergeMethod) {
-                            case utils_4.MergeMethod.CONSISTENT:
+                            case utils_5.MergeMethod.CONSISTENT:
                                 if (parentDefinitionData.appearances > enumValueData.appearances) {
                                     this.errors.push((0, errors_1.incompatibleSharedEnumError)(parentTypeName));
                                 }
                                 enumValueNodes.push(enumValueNode);
+                                if (!isValueInaccessible) {
+                                    clientEnumValueNodes.push(clientEnumValueNode);
+                                }
                                 break;
-                            case utils_4.MergeMethod.INTERSECTION:
+                            case utils_5.MergeMethod.INTERSECTION:
                                 if (parentDefinitionData.appearances === enumValueData.appearances) {
                                     enumValueNodes.push(enumValueNode);
+                                    if (!isValueInaccessible) {
+                                        clientEnumValueNodes.push(clientEnumValueNode);
+                                    }
                                 }
                                 break;
                             default:
                                 enumValueNodes.push(enumValueNode);
+                                if (!isValueInaccessible) {
+                                    clientEnumValueNodes.push(clientEnumValueNode);
+                                }
                                 break;
                         }
                     }
                     parentDefinitionData.node.values = enumValueNodes;
-                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                        this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        break;
+                    }
+                    if (clientEnumValueNodes.length < 1) {
+                        this.errors.push((0, errors_1.allChildDefinitionsAreInaccessibleError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName, 'enum value'));
+                        break;
+                    }
+                    this.clientDefinitions.push({
+                        ...parentDefinitionData.node,
+                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        values: clientEnumValueNodes,
+                    });
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
                     const invalidRequiredInputs = [];
                     const inputValueNodes = [];
+                    const clientInputValueNodes = [];
                     for (const [inputValueName, inputValueData] of parentDefinitionData.inputValueDataByValueName) {
                         if (parentDefinitionData.subgraphNames.size === inputValueData.subgraphNames.size) {
-                            inputValueNodes.push((0, utils_4.getNodeWithPersistedDirectivesByInputValueData)(inputValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                            inputValueNodes.push((0, utils_5.getNodeWithPersistedDirectivesByInputValueData)(inputValueData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                            if ((0, utils_5.isNodeDataInaccessible)(inputValueData)) {
+                                continue;
+                            }
+                            clientInputValueNodes.push({
+                                ...inputValueData.node,
+                                directives: (0, utils_5.getClientPersistedDirectiveNodes)(inputValueData),
+                            });
                         }
-                        else if ((0, utils_4.isTypeRequired)(inputValueData.type)) {
+                        else if ((0, utils_5.isTypeRequired)(inputValueData.type)) {
                             invalidRequiredInputs.push({
                                 inputValueName,
-                                missingSubgraphs: (0, utils_2.getEntriesNotInHashSet)(parentDefinitionData.subgraphNames, inputValueData.subgraphNames),
+                                missingSubgraphs: (0, utils_3.getEntriesNotInHashSet)(parentDefinitionData.subgraphNames, inputValueData.subgraphNames),
                                 requiredSubgraphs: [...inputValueData.requiredSubgraphNames],
                             });
                         }
@@ -673,24 +1229,39 @@ class FederationFactory {
                         break;
                     }
                     parentDefinitionData.node.fields = inputValueNodes;
-                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                        this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        break;
+                    }
+                    if (clientInputValueNodes.length < 1) {
+                        this.errors.push((0, errors_1.allChildDefinitionsAreInaccessibleError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName, 'input field'));
+                        break;
+                    }
+                    this.clientDefinitions.push({
+                        ...parentDefinitionData.node,
+                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        fields: clientInputValueNodes,
+                    });
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
                     const fieldNodes = [];
+                    const clientSchemaFieldNodes = [];
                     const invalidFieldNames = new Set();
                     const isObject = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION;
                     for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByFieldName) {
-                        (0, utils_4.pushAuthorizationDirectives)(fieldData, this.authorizationDataByParentTypeName.get(parentTypeName));
-                        const argumentNodes = (0, utils_4.getValidFieldArgumentNodes)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, this.fieldConfigurationByFieldPath, this.errors);
-                        if (isObject && !(0, utils_4.isShareabilityOfAllFieldInstancesValid)(fieldData)) {
+                        (0, utils_5.pushAuthorizationDirectives)(fieldData, this.authorizationDataByParentTypeName.get(parentTypeName));
+                        const argumentNodes = (0, utils_5.getValidFieldArgumentNodes)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, this.fieldConfigurationByFieldPath, this.errors);
+                        if (isObject && !(0, utils_5.isShareabilityOfAllFieldInstancesValid)(fieldData)) {
                             invalidFieldNames.add(fieldName);
                         }
+                        fieldNodes.push((0, utils_5.getNodeWithPersistedDirectivesByFieldData)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, argumentNodes, this.errors));
                         if (fieldData.isInaccessible) {
                             continue;
                         }
-                        fieldNodes.push((0, utils_4.getNodeWithPersistedDirectivesByFieldData)(fieldData, this.persistedDirectiveDefinitionByDirectiveName, argumentNodes, this.errors));
+                        clientSchemaFieldNodes.push((0, utils_5.getClientSchemaFieldNodeByFieldData)(fieldData));
                     }
                     if (isObject && invalidFieldNames.size > 0) {
                         this.errors.push((0, errors_1.invalidFieldShareabilityError)(parentDefinitionData, invalidFieldNames));
@@ -698,201 +1269,269 @@ class FederationFactory {
                     parentDefinitionData.node.fields = fieldNodes;
                     // Implemented interfaces can only be validated after all fields are merged
                     if (parentDefinitionData.implementedInterfaceTypeNames.size > 0) {
-                        definitionsWithInterfaces.push(parentDefinitionData);
-                    }
-                    else {
-                        definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                        interfaceImplementations.push({ data: parentDefinitionData, clientSchemaFieldNodes });
+                        break;
                     }
-                    if (fieldNodes.length < 1) {
-                        if ((0, utils_3.isNodeQuery)(parentTypeName)) {
-                            this.errors.push(errors_1.noQueryRootTypeError);
-                        }
-                        else {
-                            this.errors.push((0, errors_1.allFieldDefinitionsAreInaccessibleError)((0, utils_2.kindToTypeString)(parentDefinitionData.kind), parentTypeName));
+                    this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    const isQuery = (0, utils_4.isNodeQuery)(parentTypeName);
+                    if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                        if (isQuery) {
+                            this.errors.push(errors_1.inaccessibleQueryRootTypeError);
+                            break;
                         }
+                        this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        break;
+                    }
+                    if (clientSchemaFieldNodes.length < 1) {
+                        const error = isQuery
+                            ? errors_1.noQueryRootTypeError
+                            : (0, errors_1.allChildDefinitionsAreInaccessibleError)((0, utils_3.kindToTypeString)(parentDefinitionData.kind), parentTypeName, string_constants_1.FIELD);
+                        this.errors.push(error);
+                        break;
                     }
+                    this.clientDefinitions.push({
+                        ...parentDefinitionData.node,
+                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        fields: clientSchemaFieldNodes,
+                    });
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    if (!constants_1.BASE_SCALARS.has(parentTypeName)) {
-                        definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    if (constants_1.BASE_SCALARS.has(parentTypeName)) {
+                        break;
+                    }
+                    this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                        this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        break;
                     }
+                    this.clientDefinitions.push({
+                        ...parentDefinitionData.node,
+                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                    });
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                    parentDefinitionData.node.types = (0, utils_2.mapToArrayOfValues)(parentDefinitionData.memberByMemberTypeName);
-                    definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    parentDefinitionData.node.types = (0, utils_3.mapToArrayOfValues)(parentDefinitionData.memberByMemberTypeName);
+                    this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+                    if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
+                        this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        break;
+                    }
+                    const clientMembers = this.getClientSchemaUnionMembers(parentDefinitionData);
+                    if (clientMembers.length < 1) {
+                        this.errors.push((0, errors_1.allChildDefinitionsAreInaccessibleError)(string_constants_1.UNION, parentTypeName, 'union member type'));
+                        break;
+                    }
+                    this.clientDefinitions.push({
+                        ...parentDefinitionData.node,
+                        directives: (0, utils_5.getClientPersistedDirectiveNodes)(parentDefinitionData),
+                        types: clientMembers,
+                    });
                     break;
             }
         }
-        // for (const [parentTypeName, parentContainer] of this.parents) {
-        //   switch (parentContainer.kind) {
-        // case Kind.ENUM_TYPE_DEFINITION:
-        //   const values: MutableEnumValueDefinitionNode[] = [];
-        //   const mergeMethod = this.getEnumMergeMethod(parentTypeName);
-        //   for (const enumValueContainer of parentContainer.values.values()) {
-        //     pushPersistedDirectivesAndGetNode(enumValueContainer);
-        //     switch (mergeMethod) {
-        //       case MergeMethod.CONSISTENT:
-        //         if (enumValueContainer.appearances < parentContainer.appearances) {
-        //           this.errors.push(incompatibleSharedEnumError(parentTypeName));
-        //         }
-        //         values.push(enumValueContainer.node);
-        //         break;
-        //       case MergeMethod.INTERSECTION:
-        //         if (enumValueContainer.appearances === parentContainer.appearances) {
-        //           values.push(enumValueContainer.node);
-        //         }
-        //         break;
-        //       default:
-        //         values.push(enumValueContainer.node);
-        //         break;
-        //     }
-        //   }
-        //   parentContainer.node.values = values;
-        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
-        //   break;
-        // case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-        //   const inputValues: InputValueDefinitionNode[] = [];
-        //   for (const inputValueContainer of parentContainer.fields.values()) {
-        //     pushPersistedDirectivesAndGetNode(inputValueContainer);
-        //     if (parentContainer.appearances === inputValueContainer.appearances) {
-        //       inputValues.push(inputValueContainer.node);
-        //     } else if (isTypeRequired(inputValueContainer.node.type)) {
-        //       this.errors.push(federationRequiredInputFieldError(parentTypeName, inputValueContainer.node.name.value));
-        //       break;
-        //     }
-        //   }
-        //   parentContainer.node.fields = inputValues;
-        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
-        //   break;
-        // case Kind.INTERFACE_TYPE_DEFINITION:
-        //   const interfaceFields: FieldDefinitionNode[] = [];
-        //   for (const fieldContainer of parentContainer.fields.values()) {
-        //     if (isFieldInaccessible(fieldContainer)) {
-        //       continue;
-        //     }
-        //     interfaceFields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
-        //   }
-        //   parentContainer.node.fields = interfaceFields;
-        //   pushPersistedDirectivesAndGetNode(parentContainer);
-        //   // Interface implementations can only be evaluated after they've been fully merged
-        //   if (parentContainer.interfaces.size > 0) {
-        //     definitionsWithInterfaces.push(parentContainer);
-        //   } else {
-        //     definitions.push(parentContainer.node);
-        //   }
-        //   if (interfaceFields.length < 1) {
-        //     this.errors.push(allFieldDefinitionsAreInaccessibleError('interface', parentTypeName));
-        //   }
-        //   break;
-        // case Kind.OBJECT_TYPE_DEFINITION:
-        //   const fields: FieldDefinitionNode[] = [];
-        //   for (const fieldContainer of parentContainer.fields.values()) {
-        //     if (isFieldInaccessible(fieldContainer)) {
-        //       continue;
-        //     }
-        //     fields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
-        //   }
-        //   parentContainer.node.fields = fields;
-        //   pushPersistedDirectivesAndGetNode(parentContainer);
-        //   // Interface implementations can only be evaluated after they've been fully merged
-        //   if (parentContainer.interfaces.size > 0) {
-        //     definitionsWithInterfaces.push(parentContainer);
-        //   }
-        // } else {
-        //   definitions.push(parentContainer.node);
-        // }
-        // if (fields.length < 1) {
-        //   if (isNodeQuery(parentTypeName)) {
-        //     this.errors.push(noQueryRootTypeError);
-        //   } else {
-        //     this.errors.push(allFieldDefinitionsAreInaccessibleError('object', parentTypeName));
-        //   }
-        // }
-        // break;
-        // case Kind.SCALAR_TYPE_DEFINITION:
-        //   if (!BASE_SCALARS.has(parentTypeName)) {
-        //     definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
-        //   }
-        //   break;
-        // case Kind.UNION_TYPE_DEFINITION:
-        //   const types: NamedTypeNode[] = [];
-        //   for (const memberName of parentContainer.members) {
-        //     types.push(stringToNamedTypeNode(memberName));
-        //   }
-        //   parentContainer.node.types = types;
-        //   definitions.push(pushPersistedDirectivesAndGetNode(parentContainer));
-        //   break;
-        //   }
-        // }
-        for (const data of definitionsWithInterfaces) {
-            data.node.interfaces = this.getValidImplementedInterfaces(data);
-            definitions.push((0, utils_4.getNodeWithPersistedDirectivesByData)(data, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+    }
+    federateSubgraphData() {
+        this.federateInternalSubgraphData();
+        this.handleEntityInterfaces();
+        for (const [parentTypeName, objectExtensionData] of this.objectExtensionDataByTypeName) {
+            this.upsertValidObjectExtensionData(objectExtensionData);
+        }
+        // generate the map of tag data that is used by contracts
+        this.generateTagData();
+        this.pushVersionTwoDirectiveDefinitionsToDocumentDefinitions();
+    }
+    validateInterfaceImplementationsAndPushToDocumentDefinitions(interfaceImplementations) {
+        for (const { data, clientSchemaFieldNodes } of interfaceImplementations) {
+            const validInterfaces = this.getValidImplementedInterfaces(data);
+            data.node.interfaces = validInterfaces;
+            this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(data, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
+            if ((0, utils_5.isNodeDataInaccessible)(data)) {
+                this.validateReferencesOfInaccessibleType(data);
+                continue;
+            }
+            const clientInterfaces = [];
+            for (const interfaceTypeName of data.implementedInterfaceTypeNames) {
+                if (!this.inaccessiblePaths.has(interfaceTypeName)) {
+                    clientInterfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceTypeName));
+                }
+            }
+            this.clientDefinitions.push({
+                ...data.node,
+                directives: (0, utils_5.getClientPersistedDirectiveNodes)(data),
+                fields: clientSchemaFieldNodes,
+                interfaces: clientInterfaces,
+            });
+        }
+    }
+    pushVersionTwoDirectiveDefinitionsToDocumentDefinitions() {
+        if (!this.isVersionTwo) {
+            return;
+        }
+        this.routerDefinitions = [
+            constants_1.AUTHENTICATED_DEFINITION,
+            constants_1.DEPRECATED_DEFINITION,
+            constants_1.INACCESSIBLE_DEFINITION,
+            constants_1.REQUIRES_SCOPES_DEFINITION,
+            constants_1.TAG_DEFINITION,
+            constants_1.SCOPE_SCALAR_DEFINITION,
+        ];
+        this.clientDefinitions = [
+            constants_1.AUTHENTICATED_DEFINITION,
+            constants_1.DEPRECATED_DEFINITION,
+            constants_1.REQUIRES_SCOPES_DEFINITION,
+            constants_1.SCOPE_SCALAR_DEFINITION,
+        ];
+    }
+    validateReferencesOfInaccessibleType(data) {
+        const paths = this.pathsByNamedTypeName.get(data.name);
+        if (!paths || paths.size < 1) {
+            return;
+        }
+        const invalidPaths = [];
+        for (const path of paths) {
+            if (!this.inaccessiblePaths.has(path)) {
+                invalidPaths.push(path);
+            }
+        }
+        if (invalidPaths.length > 0) {
+            this.errors.push((0, errors_1.invalidReferencesOfInaccessibleTypeError)((0, utils_3.kindToTypeString)(data.kind), data.name, invalidPaths));
         }
+    }
+    validateQueryRootType() {
         const query = this.parentDefinitionDataByTypeName.get(string_constants_1.QUERY);
         if (!query || query.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION || query.fieldDataByFieldName.size < 1) {
             this.errors.push(errors_1.noQueryRootTypeError);
+            return;
+        }
+        for (const fieldData of query.fieldDataByFieldName.values()) {
+            if (!(0, utils_5.isNodeDataInaccessible)(fieldData)) {
+                return;
+            }
+        }
+        this.errors.push(errors_1.noQueryRootTypeError);
+    }
+    buildFederationResult() {
+        if (this.invalidOrScopesHostPaths.size > 0) {
+            this.errors.push((0, errors_1.orScopesLimitError)(utils_3.maxOrScopes, [...this.invalidOrScopesHostPaths]));
+        }
+        for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
+            (0, utils_5.addValidPersistedDirectiveDefinitionNodeByData)(this.routerDefinitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
         }
+        const definitionsWithInterfaces = [];
+        this.pushParentDefinitionDataToDocumentDefinitions(definitionsWithInterfaces);
+        this.validateInterfaceImplementationsAndPushToDocumentDefinitions(definitionsWithInterfaces);
+        this.validateQueryRootType();
         // return any composition errors before checking whether all fields are resolvable
         if (this.errors.length > 0) {
             return { errors: this.errors };
         }
-        // TODO add back resolvability check
-        for (const rootTypeName of string_constants_1.ROOT_TYPES) {
-            const rootTypeData = this.parentDefinitionDataByTypeName.get(rootTypeName);
-            if (!rootTypeData || rootTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                continue;
+        /* Resolvability evaluations are not necessary for contracts because the source graph resolvability checks must
+         ** have already completed without error. */
+        const warnings = this.warnings.length > 0 ? { warnings: this.warnings } : {};
+        this.evaluateRootNodeFieldsResolvability();
+        if (this.errors.length > 0) {
+            return { errors: this.errors, ...warnings };
+        }
+        const newRouterAST = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: this.routerDefinitions,
+        };
+        const newClientAST = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: this.clientDefinitions,
+        };
+        const subgraphConfigBySubgraphName = new Map();
+        for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
+            subgraphConfigBySubgraphName.set(subgraph.name, {
+                configurationDataMap: subgraph.configurationDataByParentTypeName,
+                schema: subgraph.schema,
+            });
+        }
+        for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
+            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+        }
+        return {
+            federationResult: {
+                fieldConfigurations: Array.from(this.fieldConfigurationByFieldPath.values()),
+                subgraphConfigBySubgraphName,
+                federatedGraphAST: newRouterAST,
+                federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST),
+                federatedGraphClientSchema: (0, graphql_1.buildASTSchema)(newClientAST),
+            },
+            ...warnings,
+        };
+    }
+    buildFederationContractResult(tagExclusions) {
+        if (!this.isVersionTwo) {
+            /* If all the subgraphs are version one, the @inaccessible directive won't be present.
+             ** However, contracts require @inaccessible to exclude applicable tagged types. */
+            this.routerDefinitions.push(constants_1.INACCESSIBLE_DEFINITION);
+        }
+        for (const [typeName, parentTagData] of this.parentTagDataByTypeName) {
+            // TODO assess children
+            const parentDefinitionData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, string_constants_1.PARENT_DEFINITION_DATA);
+            if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, parentTagData.tagNames)) {
+                (0, utils_3.getValueOrDefault)(parentDefinitionData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+                    (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                ]);
             }
-            // After evaluating all of a root type's fields, break and return if there are errors
-            if (this.errors.length > 0) {
-                break;
+            if (parentTagData.childTagDataByChildName.size < 1) {
+                continue;
             }
-            // If a root type field returns a Scalar or Enum, track it so that it is not evaluated it again
-            const evaluatedRootScalarsAndEnums = new Set(constants_1.BASE_SCALARS);
-            for (const [rootTypeFieldName, fieldData] of rootTypeData.fieldDataByFieldName) {
-                const namedRootFieldTypeName = fieldData.namedTypeName;
-                if (evaluatedRootScalarsAndEnums.has(namedRootFieldTypeName)) {
-                    continue;
-                }
-                if (!this.shouldEvaluateObjectLike(fieldData.subgraphNames, namedRootFieldTypeName)) {
+            switch (parentDefinitionData.kind) {
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                // intentional fallthrough
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
                     continue;
-                }
-                const namedTypeData = (0, utils_2.getOrThrowError)(this.parentDefinitionDataByTypeName, namedRootFieldTypeName, 'parentDefinitionDataByTypeName');
-                const fieldPath = `${rootTypeName}.${rootTypeFieldName}`;
-                const rootTypeFieldData = {
-                    fieldName: rootTypeFieldName,
-                    fieldTypeNodeString: (0, merge_1.printTypeNode)(fieldData.node.type),
-                    path: fieldPath,
-                    typeName: rootTypeName,
-                    subgraphs: fieldData.subgraphNames,
-                };
-                switch (namedTypeData.kind) {
-                    case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                    // intentional fallthrough
-                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                        // Root type fields whose response type is an Enums and Scalars will always be resolvable
-                        // Consequently, subsequent checks can be skipped
-                        evaluatedRootScalarsAndEnums.add(namedRootFieldTypeName);
-                        continue;
-                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(namedTypeData, rootTypeFieldData, fieldPath, new Set(), this.entityDataByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
-                        continue;
-                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                    // intentional fallthrough
-                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(namedRootFieldTypeName, namedTypeData.kind, rootTypeFieldData, fieldPath, new Set(), this.entityDataByTypeName.has(namedRootFieldTypeName) ? [namedRootFieldTypeName] : []);
-                        continue;
-                    default:
-                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_2.kindToTypeString)(namedTypeData.kind)));
-                }
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                    for (const [inputFieldName, childTagData] of parentTagData.childTagDataByChildName) {
+                        const inputValueData = (0, utils_3.getOrThrowError)(parentDefinitionData.inputValueDataByValueName, inputFieldName, 'parentDefinitionData.inputValueDataByValueName');
+                        if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, childTagData.tagNames)) {
+                            (0, utils_3.getValueOrDefault)(inputValueData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+                                (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                            ]);
+                        }
+                    }
+                    break;
+                default:
+                    for (const [fieldName, childTagData] of parentTagData.childTagDataByChildName) {
+                        const fieldData = (0, utils_3.getOrThrowError)(parentDefinitionData.fieldDataByFieldName, fieldName, 'parentDefinitionData.fieldDataByFieldName');
+                        if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, childTagData.tagNames)) {
+                            (0, utils_3.getValueOrDefault)(fieldData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+                                (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                            ]);
+                        }
+                        for (const [argumentName, tagNames] of childTagData.tagNamesByArgumentName) {
+                            const inputValueData = (0, utils_3.getOrThrowError)(fieldData.argumentDataByArgumentName, argumentName, 'fieldData.argumentDataByArgumentName');
+                            if ((0, utils_3.doSetsHaveAnyOverlap)(tagExclusions, tagNames)) {
+                                (0, utils_3.getValueOrDefault)(inputValueData.persistedDirectivesData.directives, string_constants_1.INACCESSIBLE, () => [
+                                    (0, utils_3.generateSimpleDirective)(string_constants_1.INACCESSIBLE),
+                                ]);
+                            }
+                        }
+                    }
             }
         }
+        for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
+            (0, utils_5.addValidPersistedDirectiveDefinitionNodeByData)(this.routerDefinitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
+        }
+        const interfaceImplementations = [];
+        this.pushParentDefinitionDataToDocumentDefinitions(interfaceImplementations);
+        this.validateInterfaceImplementationsAndPushToDocumentDefinitions(interfaceImplementations);
+        this.validateQueryRootType();
         const warnings = this.warnings.length > 0 ? this.warnings : undefined;
         if (this.errors.length > 0) {
             return { errors: this.errors, warnings };
         }
-        const newAst = {
+        const newRouterAST = {
             kind: graphql_1.Kind.DOCUMENT,
-            definitions,
+            definitions: this.routerDefinitions,
+        };
+        const newClientAST = {
+            kind: graphql_1.Kind.DOCUMENT,
+            definitions: this.clientDefinitions,
         };
         const subgraphConfigBySubgraphName = new Map();
         for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
@@ -902,21 +1541,26 @@ class FederationFactory {
             });
         }
         for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
-            (0, utils_2.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
         }
         return {
             federationResult: {
                 fieldConfigurations: Array.from(this.fieldConfigurationByFieldPath.values()),
                 subgraphConfigBySubgraphName,
-                federatedGraphAST: newAst,
-                federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
+                federatedGraphAST: newRouterAST,
+                federatedGraphSchema: (0, graphql_1.buildASTSchema)(newRouterAST),
+                federatedGraphClientSchema: (0, graphql_1.buildASTSchema)(newClientAST),
             },
             warnings,
         };
     }
+    federateSubgraphsInternal() {
+        this.federateSubgraphData();
+        return this.buildFederationResult();
+    }
 }
 exports.FederationFactory = FederationFactory;
-function federateSubgraphs(subgraphs) {
+function initializeFederationFactory(subgraphs) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError] };
     }
@@ -931,7 +1575,7 @@ function federateSubgraphs(subgraphs) {
         for (const [typeName, entityInterfaceData] of internalSubgraph.entityInterfaces) {
             // Always add each entity interface to the invalid entity interfaces map
             // If not, earlier checks would not account for implementations not yet seen
-            const invalidEntityInterfaces = (0, utils_2.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []);
+            const invalidEntityInterfaces = (0, utils_3.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []);
             invalidEntityInterfaces.push({
                 subgraphName,
                 concreteTypeNames: entityInterfaceData.concreteTypeNames || new Set(),
@@ -939,10 +1583,10 @@ function federateSubgraphs(subgraphs) {
             const existingData = entityInterfaceFederationDataByTypeName.get(typeName);
             if (!existingData) {
                 validEntityInterfaceTypeNames.add(typeName);
-                entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_2.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
+                entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_3.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
                 continue;
             }
-            const areAnyImplementationsUndefined = (0, utils_2.upsertEntityInterfaceFederationData)(existingData, entityInterfaceData, subgraphName);
+            const areAnyImplementationsUndefined = (0, utils_3.upsertEntityInterfaceFederationData)(existingData, entityInterfaceData, subgraphName);
             if (areAnyImplementationsUndefined) {
                 validEntityInterfaceTypeNames.delete(typeName);
             }
@@ -959,7 +1603,55 @@ function federateSubgraphs(subgraphs) {
             ],
         };
     }
-    return new FederationFactory(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainerByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings).federate();
+    return {
+        federationFactory: new FederationFactory(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainerByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings),
+    };
+}
+function federateSubgraphs(subgraphs) {
+    const { errors, federationFactory } = initializeFederationFactory(subgraphs);
+    if (errors || !federationFactory) {
+        return { errors: errors || [errors_1.federationFactoryInitializationFatalError] };
+    }
+    return federationFactory.federateSubgraphsInternal();
 }
 exports.federateSubgraphs = federateSubgraphs;
+// the flow when publishing a subgraph that also has contracts
+function federateSubgraphsWithContracts(subgraphs, tagExclusionsByContractName) {
+    const { errors: normalizationErrors, federationFactory } = initializeFederationFactory(subgraphs);
+    if (normalizationErrors || !federationFactory) {
+        return { errors: normalizationErrors || [errors_1.federationFactoryInitializationFatalError] };
+    }
+    federationFactory.federateSubgraphData();
+    const federationFactories = [(0, lodash_1.cloneDeep)(federationFactory)];
+    const { errors, federationResult, warnings } = federationFactory.buildFederationResult();
+    // if the base graph fails composition, no contracts will be attempted
+    if (errors) {
+        return { errors, warnings };
+    }
+    const lastContractIndex = tagExclusionsByContractName.size - 1;
+    const federationResultContainerByContractName = new Map();
+    let i = 0;
+    for (const [contractName, tagExclusions] of tagExclusionsByContractName) {
+        // deep copy the current FederationFactory before it is mutated if it is not the last one required
+        if (i !== lastContractIndex) {
+            federationFactories.push((0, lodash_1.cloneDeep)(federationFactories[i]));
+        }
+        // note that any one contract could have its own errors
+        const federationResultContainer = federationFactories[i].buildFederationContractResult(tagExclusions);
+        federationResultContainerByContractName.set(contractName, federationResultContainer);
+        i++;
+    }
+    return { federationResult, federationResultContainerByContractName };
+}
+exports.federateSubgraphsWithContracts = federateSubgraphsWithContracts;
+// the flow when adding a completely new contract
+function federateSubgraphsContract(subgraphs, tagExclusions) {
+    const { errors, federationFactory } = initializeFederationFactory(subgraphs);
+    if (errors || !federationFactory) {
+        return { errors: errors || [errors_1.federationFactoryInitializationFatalError] };
+    }
+    federationFactory.federateSubgraphData();
+    return federationFactory.buildFederationContractResult(tagExclusions);
+}
+exports.federateSubgraphsContract = federateSubgraphsContract;
 //# sourceMappingURL=federation-factory.js.map