@wundergraph/composition 0.27.1 → 0.28.0

package/dist/federation/federation-factory.js

@@ -28,12 +28,11 @@ class FederationFactory {
     entityDataByTypeName;
     entityInterfaceFederationDataByTypeName;
     errors = [];
-    evaluatedObjectLikesBySubgraph = new Map();
     fieldConfigurationByFieldPath = new Map();
-    graph;
     graphEdges = new Set();
     graphPaths = new Map();
     inaccessiblePaths = new Set();
+    internalGraph;
     internalSubgraphBySubgraphName;
     invalidOrScopesHostPaths = new Set();
     isVersionTwo = false;
@@ -63,8 +62,8 @@ class FederationFactory {
         this.concreteTypeNamesByAbstractTypeName = options.concreteTypeNamesByAbstractTypeName;
         this.entityDataByTypeName = options.entityDataByTypeName;
         this.entityInterfaceFederationDataByTypeName = options.entityInterfaceFederationDataByTypeName;
-        this.graph = options.graph;
         this.internalSubgraphBySubgraphName = options.internalSubgraphBySubgraphName;
+        this.internalGraph = options.internalGraph;
         this.warnings = options.warnings || [];
     }
     getValidImplementedInterfaces(data) {
@@ -163,295 +162,85 @@ class FederationFactory {
         }
         return interfaces;
     }
-    isFieldResolvableByEntityAncestor(entityAncestors, fieldSubgraphs, parentTypeName) {
-        if (!this.graph.hasNode(parentTypeName)) {
-            return false;
-        }
-        for (const entityAncestorName of entityAncestors) {
-            const path = `${entityAncestorName}.${parentTypeName}`;
-            if (entityAncestorName !== parentTypeName && this.graphPaths.get(path)) {
-                return true;
-            }
-            if (entityAncestorName === parentTypeName) {
-                const hasOverlap = (0, utils_3.doSetsIntersect)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityDataByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
-                this.graphPaths.set(path, hasOverlap);
-                return hasOverlap;
-            }
-            if ((0, utils_3.hasSimplePath)(this.graph, entityAncestorName, parentTypeName)) {
-                this.graphPaths.set(path, true);
-                return true;
-            }
-            this.graphPaths.set(path, false);
-        }
-        return false;
-    }
-    shouldEvaluateObjectLike(rootTypeFieldSubgraphs, parentTypeName) {
-        for (const subgraph of rootTypeFieldSubgraphs) {
-            const evaluatedObjectLikes = this.evaluatedObjectLikesBySubgraph.get(subgraph);
-            if (evaluatedObjectLikes && evaluatedObjectLikes.has(parentTypeName)) {
-                continue;
-            }
-            return true;
-        }
-        return false;
-    }
-    updateEvaluatedSubgraphOccurrences(rootTypeFieldSubgraphs, objectSubgraphs, entityAncestors, parentTypeName) {
-        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, objectSubgraphs);
-        if (mutualSubgraphs.size > 0) {
-            for (const mutualSubgraph of mutualSubgraphs) {
-                const evaluatedObjects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
-                if (evaluatedObjects) {
-                    evaluatedObjects.add(parentTypeName);
-                }
-                else {
-                    this.evaluatedObjectLikesBySubgraph.set(mutualSubgraph, new Set([parentTypeName]));
-                }
-            }
-        }
-        for (const entityAncestorTypeName of entityAncestors) {
-            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) {
-                    objects.add(parentTypeName);
-                }
-                else {
-                    this.evaluatedObjectLikesBySubgraph.set(mutualSubgraphName, new Set([parentTypeName]));
-                }
-            }
-        }
-    }
-    evaluateResolvabilityOfObject(objectData, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, isParentAbstract = false) {
-        const parentTypeName = objectData.name;
-        if (evaluatedObjectLikes.has(parentTypeName)) {
+    addValidPrimaryKeyTargetsToEntityData(entityData) {
+        if (!entityData) {
             return;
         }
-        if (!this.shouldEvaluateObjectLike(rootTypeFieldData.subgraphs, parentTypeName)) {
-            evaluatedObjectLikes.add(parentTypeName);
-            return;
+        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);
+        if (!objectData ||
+            (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);
         }
-        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;
-            }
-            // Avoid an infinite loop with self-referential objects
-            if (evaluatedObjectLikes.has(namedFieldTypeName)) {
-                continue;
-            }
-            if ((0, utils_5.isFieldExternalInAllMutualSubgraphs)(rootTypeFieldData.subgraphs, fieldData)) {
+        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityData.typeName, 'internalSubgraph.configurationDataByParentTypeName');
+        const implicitKeys = [];
+        const graphNode = this.internalGraph.nodeByNodeName.get(`${this.currentSubgraphName}.${entityData.typeName}`);
+        // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
+        (0, utils_2.validateImplicitFieldSets)({
+            configurationData,
+            fieldSets: entityData.keyFieldSets,
+            implicitKeys,
+            objectData,
+            parentDefinitionDataByTypeName,
+            parentExtensionDataByTypeName,
+            graphNode,
+        });
+        for (const [typeName, entityInterfaceFederationData] of this.entityInterfaceFederationDataByTypeName) {
+            if (!entityInterfaceFederationData.concreteTypeNames?.has(entityData.typeName)) {
                 continue;
             }
-            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, objectData.subgraphNames, entityAncestors, parentTypeName);
-            evaluatedObjectLikes.add(parentTypeName);
-            const isFieldResolvable = (0, utils_3.doSetsIntersect)(rootTypeFieldData.subgraphs, fieldData.subgraphNames) ||
-                this.isFieldResolvableByEntityAncestor(entityAncestors, fieldData.subgraphNames, parentTypeName);
-            const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
-            const entity = this.entityDataByTypeName.get(namedFieldTypeName);
-            if (isFieldResolvable) {
-                // The base scalars are not in this.parentMap
-                if (constants_1.BASE_SCALARS.has(namedFieldTypeName)) {
-                    continue;
-                }
-                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
-                    case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                        continue;
-                    case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(namedTypeData, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, namedFieldTypeName] : [...entityAncestors]);
-                        continue;
-                    case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                    // intentional fallthrough
-                    case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(namedFieldTypeName, namedTypeData.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, namedFieldTypeName] : [...entityAncestors]);
-                        continue;
-                    default:
-                        this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(namedTypeData.kind)));
-                        continue;
-                }
-            }
-            if (constants_1.BASE_SCALARS.has(namedFieldTypeName)) {
-                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath, parentTypeName));
+            const interfaceObjectEntityData = this.entityDataByTypeName.get(typeName);
+            if (!interfaceObjectEntityData) {
                 continue;
             }
-            const namedTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, namedFieldTypeName, 'parentDefinitionDataByTypeName');
-            switch (namedTypeData.kind) {
-                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-                // intentional fallthrough
-                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldData.subgraphNames], newCurrentFieldPath, parentTypeName));
-                    continue;
-                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-                // intentional fallthrough
-                case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                // intentional fallthrough
-                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    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_3.kindToTypeString)(namedTypeData.kind)));
-            }
+            (0, utils_2.validateImplicitFieldSets)({
+                configurationData,
+                fieldSets: interfaceObjectEntityData.keyFieldSets,
+                implicitKeys,
+                objectData,
+                parentDefinitionDataByTypeName,
+                parentExtensionDataByTypeName,
+                graphNode,
+            });
         }
-    }
-    evaluateResolvabilityOfAbstractType(abstractTypeName, abstractKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors) {
-        if (evaluatedObjectLikes.has(abstractTypeName)) {
+        if (implicitKeys.length < 1) {
             return;
         }
-        evaluatedObjectLikes.add(abstractTypeName);
-        const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(abstractTypeName);
-        if (!concreteTypeNames) {
-            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(abstractKind), abstractTypeName);
+        if (!configurationData.keys || configurationData.keys.length < 1) {
+            configurationData.isRootNode = true;
+            configurationData.keys = implicitKeys;
             return;
         }
-        for (const concreteTypeName of concreteTypeNames) {
-            if (evaluatedObjectLikes.has(concreteTypeName)) {
-                continue;
-            }
-            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_3.kindToTypeString)(concreteTypeData.kind));
-            }
-            // If the concrete type is unreachable through an inline fragment, it is not an error
-            if (!(0, utils_3.doSetsIntersect)(concreteTypeData.subgraphNames, rootTypeFieldData.subgraphs)) {
+        const existingKeys = new Set(configurationData.keys.map((key) => key.selectionSet));
+        for (const implicitKey of implicitKeys) {
+            if (existingKeys.has(implicitKey.selectionSet)) {
                 continue;
             }
-            const entity = this.entityDataByTypeName.get(concreteTypeName);
-            this.evaluateResolvabilityOfObject(concreteTypeData, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, evaluatedObjectLikes, entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
+            configurationData.keys.push(implicitKey);
+            existingKeys.add(implicitKey.selectionSet);
         }
     }
-    addValidPrimaryKeyTargetsToEntityData(entityData) {
-        if (!entityData) {
-            return;
-        }
-        const internalSubgraph = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
+    addValidPrimaryKeyTargetsFromInterfaceObject(internalSubgraph, interfaceObjectTypeName, entityData, graphNode) {
         const parentDefinitionDataByTypeName = internalSubgraph.parentDefinitionDataByTypeName;
         const parentExtensionDataByTypeName = internalSubgraph.parentExtensionDataByTypeName;
-        const objectData = parentDefinitionDataByTypeName.get(entityData.typeName) || parentExtensionDataByTypeName.get(entityData.typeName);
-        if (!objectData ||
-            (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 interfaceObjectData = parentDefinitionDataByTypeName.get(interfaceObjectTypeName);
+        if (!interfaceObjectData || interfaceObjectData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+            throw (0, errors_1.incompatibleParentKindFatalError)(interfaceObjectTypeName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceObjectData?.kind || graphql_1.Kind.NULL);
         }
-        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityData.typeName, 'internalSubgraph.configurationDataMap');
-        const keyFieldNames = new Set();
+        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataByParentTypeName, entityData.typeName, 'internalSubgraph.configurationDataByParentTypeName');
         const implicitKeys = [];
         // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
-        for (const fieldSet of entityData.keyFieldSets) {
-            // Create a new selection set so that the value can be parsed as a new DocumentNode
-            const { error, documentNode } = (0, utils_1.safeParse)('{' + fieldSet + '}');
-            if (error || !documentNode) {
-                // This would be caught as an error elsewhere
-                continue;
-            }
-            const parentDatas = [objectData];
-            const definedFields = [];
-            let currentDepth = -1;
-            let shouldDefineSelectionSet = true;
-            let shouldAddKeyFieldSet = true;
-            (0, graphql_1.visit)(documentNode, {
-                Argument: {
-                    enter() {
-                        // Fields that define arguments are never allowed in a key FieldSet
-                        // However, at this stage, it actually means the argument is undefined on the field
-                        shouldAddKeyFieldSet = false;
-                        return graphql_1.BREAK;
-                    },
-                },
-                Field: {
-                    enter(node) {
-                        const parentData = parentDatas[currentDepth];
-                        // If an object-like was just visited, a selection set should have been entered
-                        if (shouldDefineSelectionSet) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        const fieldName = node.name.value;
-                        const fieldData = parentData.fieldDataByFieldName.get(fieldName);
-                        // undefined if the field does not exist on the parent
-                        if (!fieldData || fieldData.argumentDataByArgumentName.size || definedFields[currentDepth].has(fieldName)) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        definedFields[currentDepth].add(fieldName);
-                        // Depth 0 is the original parent type
-                        // If a field is external, but it's part of a key FieldSet, it will be included in the root configuration
-                        if (currentDepth === 0) {
-                            keyFieldNames.add(fieldName);
-                        }
-                        const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
-                        // The base scalars are not in the parents map
-                        if (constants_1.BASE_SCALARS.has(namedTypeName)) {
-                            return;
-                        }
-                        // The child could itself be a parent and could exist as an object extension
-                        const fieldNamedTypeData = parentDefinitionDataByTypeName.get(namedTypeName) || parentExtensionDataByTypeName.get(namedTypeName);
-                        if (!fieldNamedTypeData) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        if (fieldNamedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
-                            fieldNamedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-                            shouldDefineSelectionSet = true;
-                            parentDatas.push(fieldNamedTypeData);
-                            return;
-                        }
-                        // interfaces and unions are invalid in a key directive
-                        if ((0, utils_1.isKindAbstract)(fieldNamedTypeData.kind)) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                    },
-                },
-                InlineFragment: {
-                    enter() {
-                        shouldAddKeyFieldSet = false;
-                        return graphql_1.BREAK;
-                    },
-                },
-                SelectionSet: {
-                    enter() {
-                        if (!shouldDefineSelectionSet) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        currentDepth += 1;
-                        shouldDefineSelectionSet = false;
-                        if (currentDepth < 0 || currentDepth >= parentDatas.length) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        definedFields.push(new Set());
-                    },
-                    leave() {
-                        if (shouldDefineSelectionSet) {
-                            shouldAddKeyFieldSet = false;
-                            return graphql_1.BREAK;
-                        }
-                        // Empty selection sets would be a parse error, so it is unnecessary to handle them
-                        currentDepth -= 1;
-                        parentDatas.pop();
-                        definedFields.pop();
-                    },
-                },
-            });
-            if (!shouldAddKeyFieldSet) {
-                continue;
-            }
-            // Add any top-level fields that compose the key in case they are external
-            (0, utils_3.addIterableValuesToSet)(keyFieldNames, configurationData.fieldNames);
-            implicitKeys.push({
-                fieldName: '',
-                selectionSet: (0, utils_4.getNormalizedFieldSet)(documentNode),
-                disableEntityResolver: true,
-            });
-        }
+        (0, utils_2.validateImplicitFieldSets)({
+            configurationData,
+            fieldSets: entityData.keyFieldSets,
+            implicitKeys,
+            objectData: interfaceObjectData,
+            parentDefinitionDataByTypeName,
+            parentExtensionDataByTypeName,
+            graphNode,
+        });
         if (implicitKeys.length < 1) {
             return;
         }
@@ -512,60 +301,6 @@ class FederationFactory {
             }
         }
     }
-    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, isParentInaccessible) {
         const existingData = enumValueDataByValueName.get(incomingData.name);
         const baseData = existingData || incomingData;
@@ -752,10 +487,10 @@ class FederationFactory {
         if (isParentInaccessible) {
             this.inaccessiblePaths.add(incomingData.name);
         }
+        if (entityInterfaceData && entityInterfaceData.interfaceObjectSubgraphs.has(subgraphName)) {
+            incomingData.kind = graphql_1.Kind.INTERFACE_TYPE_DEFINITION;
+        }
         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),
@@ -1072,7 +807,7 @@ class FederationFactory {
             subgraphNumber += 1;
             this.currentSubgraphName = internalSubgraph.name;
             this.isVersionTwo ||= internalSubgraph.isVersionTwo;
-            (0, walkers_1.createMultiGraphAndRenameRootTypes)(this, internalSubgraph);
+            (0, walkers_1.renameRootTypes)(this, internalSubgraph);
             for (const parentDefinitionData of internalSubgraph.parentDefinitionDataByTypeName.values()) {
                 this.upsertParentDefinitionData(parentDefinitionData, internalSubgraph.name);
             }
@@ -1098,21 +833,38 @@ class FederationFactory {
             }
         }
     }
+    handleInterfaceObjectForInternalGraph({ entityData, internalSubgraph, interfaceObjectData, interfaceObjectNode, resolvableKeyFieldSets, subgraphName, }) {
+        const entityGraphNode = this.internalGraph.addOrUpdateNode(entityData.typeName);
+        const entityDataNode = this.internalGraph.addEntityDataNode(entityData.typeName);
+        for (const satisfiedFieldSet of interfaceObjectNode.satisfiedFieldSets) {
+            entityGraphNode.satisfiedFieldSets.add(satisfiedFieldSet);
+            if (resolvableKeyFieldSets.has(satisfiedFieldSet)) {
+                entityDataNode.addTargetSubgraphByFieldSet(satisfiedFieldSet, subgraphName);
+            }
+        }
+        const fieldDatas = interfaceObjectData.fieldDatasBySubgraphName.get(subgraphName);
+        for (const { name, namedTypeName } of fieldDatas || []) {
+            this.internalGraph.addEdge(entityGraphNode, this.internalGraph.addOrUpdateNode(namedTypeName), name);
+        }
+        this.internalGraph.addEdge(interfaceObjectNode, entityGraphNode, entityData.typeName, true);
+        this.addValidPrimaryKeyTargetsFromInterfaceObject(internalSubgraph, interfaceObjectNode.typeName, entityData, entityGraphNode);
+    }
     handleEntityInterfaces() {
-        for (const [typeName, entityInterfaceData] of this.entityInterfaceFederationDataByTypeName) {
+        for (const [entityInterfaceTypeName, entityInterfaceData] of this.entityInterfaceFederationDataByTypeName) {
             (0, utils_3.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
-            const entityInterface = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, typeName, string_constants_1.PARENT_DEFINITION_DATA);
+            const entityInterface = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, entityInterfaceTypeName, 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_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataByParentTypeName;
-                const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(typeName);
+                const internalSubgraph = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName');
+                const configurationDataMap = internalSubgraph.configurationDataByParentTypeName;
+                const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(entityInterfaceTypeName);
                 if (!concreteTypeNames) {
                     continue;
                 }
-                const interfaceObjectConfiguration = (0, utils_3.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
+                const interfaceObjectConfiguration = (0, utils_3.getOrThrowError)(configurationDataMap, entityInterfaceTypeName, 'configurationDataMap');
                 const keys = interfaceObjectConfiguration.keys;
                 if (!keys) {
                     // TODO no keys error
@@ -1121,6 +873,8 @@ class FederationFactory {
                 interfaceObjectConfiguration.entityInterfaceConcreteTypeNames = entityInterfaceData.concreteTypeNames;
                 const fieldNames = interfaceObjectConfiguration.fieldNames;
                 const authorizationData = this.authorizationDataByParentTypeName.get(entityInterfaceData.typeName);
+                this.internalGraph.setSubgraphName(subgraphName);
+                const interfaceObjectNode = this.internalGraph.addOrUpdateNode(entityInterfaceTypeName, { isAbstract: true });
                 for (const concreteTypeName of concreteTypeNames) {
                     if (configurationDataMap.has(concreteTypeName)) {
                         // error TODO
@@ -1139,31 +893,48 @@ class FederationFactory {
                         continue;
                     }
                     // The subgraph locations of the interface object must be added to the concrete types that implement it
-                    const entity = this.entityDataByTypeName.get(concreteTypeName);
-                    if (entity) {
-                        // TODO error if not an entity
-                        entity.subgraphNames.add(subgraphName);
-                    }
+                    const entityData = (0, utils_3.getOrThrowError)(this.entityDataByTypeName, concreteTypeName, 'entityDataByTypeName');
+                    entityData.subgraphNames.add(subgraphName);
                     const configurationData = {
                         fieldNames,
                         isRootNode: true,
                         keys,
                         typeName: concreteTypeName,
                     };
+                    const resolvableKeyFieldSets = new Set();
+                    for (const key of keys.filter((k) => !k.disableEntityResolver)) {
+                        resolvableKeyFieldSets.add(key.selectionSet);
+                    }
                     for (const fieldName of entityInterfaceData.interfaceObjectFieldNames) {
                         const existingFieldData = concreteTypeData.fieldDataByFieldName.get(fieldName);
                         if (existingFieldData) {
                             // TODO handle shareability
                             continue;
                         }
-                        const interfaceFieldData = (0, utils_3.getOrThrowError)(entityInterface.fieldDataByFieldName, fieldName, `${typeName}.fieldDataByFieldName`);
+                        const interfaceFieldData = (0, utils_3.getOrThrowError)(entityInterface.fieldDataByFieldName, fieldName, `${entityInterfaceTypeName}.fieldDataByFieldName`);
                         concreteTypeData.fieldDataByFieldName.set(fieldName, { ...interfaceFieldData });
                     }
                     configurationDataMap.set(concreteTypeName, configurationData);
+                    this.handleInterfaceObjectForInternalGraph({
+                        internalSubgraph,
+                        subgraphName,
+                        interfaceObjectData: entityInterfaceData,
+                        interfaceObjectNode,
+                        resolvableKeyFieldSets,
+                        entityData,
+                    });
                 }
             }
         }
     }
+    fieldDataToGraphFieldData(fieldData) {
+        return {
+            name: fieldData.name,
+            namedTypeName: fieldData.namedTypeName,
+            isLeaf: (0, utils_3.isNodeLeaf)(this.parentDefinitionDataByTypeName.get(fieldData.namedTypeName)?.kind),
+            subgraphNames: fieldData.subgraphNames,
+        };
+    }
     pushParentDefinitionDataToDocumentDefinitions(interfaceImplementations) {
         for (const [parentTypeName, parentDefinitionData] of this.parentDefinitionDataByTypeName) {
             switch (parentDefinitionData.kind) {
@@ -1208,6 +979,7 @@ class FederationFactory {
                     this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
                         break;
                     }
                     if (clientEnumValueNodes.length < 1) {
@@ -1268,6 +1040,7 @@ class FederationFactory {
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
                     const fieldNodes = [];
                     const clientSchemaFieldNodes = [];
+                    const graphFieldDataByFieldName = new Map();
                     const invalidFieldNames = new Set();
                     const isObject = parentDefinitionData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION;
                     for (const [fieldName, fieldData] of parentDefinitionData.fieldDataByFieldName) {
@@ -1281,11 +1054,13 @@ class FederationFactory {
                             continue;
                         }
                         clientSchemaFieldNodes.push((0, utils_5.getClientSchemaFieldNodeByFieldData)(fieldData));
+                        graphFieldDataByFieldName.set(fieldName, this.fieldDataToGraphFieldData(fieldData));
                     }
                     if (isObject && invalidFieldNames.size > 0) {
                         this.errors.push((0, errors_1.invalidFieldShareabilityError)(parentDefinitionData, invalidFieldNames));
                     }
                     parentDefinitionData.node.fields = fieldNodes;
+                    this.internalGraph.initializeNode(parentTypeName, graphFieldDataByFieldName);
                     // Implemented interfaces can only be validated after all fields are merged
                     if (parentDefinitionData.implementedInterfaceTypeNames.size > 0) {
                         interfaceImplementations.push({ data: parentDefinitionData, clientSchemaFieldNodes });
@@ -1299,6 +1074,7 @@ class FederationFactory {
                             break;
                         }
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
                         break;
                     }
                     if (clientSchemaFieldNodes.length < 1) {
@@ -1321,6 +1097,7 @@ class FederationFactory {
                     this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
                         break;
                     }
                     this.clientDefinitions.push({
@@ -1333,6 +1110,7 @@ class FederationFactory {
                     this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(parentDefinitionData, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
                     if ((0, utils_5.isNodeDataInaccessible)(parentDefinitionData)) {
                         this.validateReferencesOfInaccessibleType(parentDefinitionData);
+                        this.internalGraph.setNodeInaccessible(parentDefinitionData.name);
                         break;
                     }
                     const clientMembers = this.getClientSchemaUnionMembers(parentDefinitionData);
@@ -1365,6 +1143,7 @@ class FederationFactory {
             this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(data, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
             if ((0, utils_5.isNodeDataInaccessible)(data)) {
                 this.validateReferencesOfInaccessibleType(data);
+                this.internalGraph.setNodeInaccessible(data.name);
                 continue;
             }
             const clientInterfaces = [];
@@ -1373,6 +1152,9 @@ class FederationFactory {
                     clientInterfaces.push((0, utils_1.stringToNamedTypeNode)(interfaceTypeName));
                 }
             }
+            /* It is not possible for clientSchemaFieldNodes to be empty.
+             * If all interface fields were declared @inaccessible, the error would be caught above.
+             * */
             this.clientDefinitions.push({
                 ...data.node,
                 directives: (0, utils_5.getClientPersistedDirectiveNodes)(data),
@@ -1706,14 +1488,20 @@ class FederationFactory {
         this.pushParentDefinitionDataToDocumentDefinitions(definitionsWithInterfaces);
         this.validateInterfaceImplementationsAndPushToDocumentDefinitions(definitionsWithInterfaces);
         this.validateQueryRootType();
-        // return any composition errors before checking whether all fields are resolvable
+        // Return any composition errors before checking whether all fields are resolvable
         if (this.errors.length > 0) {
             return { errors: this.errors };
         }
         /* Resolvability evaluations are not necessary for contracts because the source graph resolvability checks must
-         ** have already completed without error. */
+         * have already completed without error. */
         const warnings = this.warnings.length > 0 ? { warnings: this.warnings } : {};
-        this.evaluateRootNodeFieldsResolvability();
+        // Resolvability checks are unnecessary for a single subgraph
+        if (this.internalSubgraphBySubgraphName.size > 1) {
+            const resolvabilityErrors = this.internalGraph.validate();
+            if (resolvabilityErrors.length > 0) {
+                return { errors: resolvabilityErrors, ...warnings };
+            }
+        }
         if (this.errors.length > 0) {
             return { errors: this.errors, ...warnings };
         }
@@ -1902,7 +1690,7 @@ function initializeFederationFactory(subgraphs) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError] };
     }
-    const { authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityDataByTypeName, errors, graph, internalSubgraphBySubgraphName, warnings, } = (0, normalization_factory_1.batchNormalize)(subgraphs);
+    const { authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityDataByTypeName, errors, internalSubgraphBySubgraphName, internalGraph, warnings, } = (0, normalization_factory_1.batchNormalize)(subgraphs);
     if (errors) {
         return { errors };
     }
@@ -1913,8 +1701,7 @@ function initializeFederationFactory(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_3.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []);
-            invalidEntityInterfaces.push({
+            (0, utils_3.getValueOrDefault)(invalidEntityInterfacesByTypeName, typeName, () => []).push({
                 subgraphName,
                 concreteTypeNames: entityInterfaceData.concreteTypeNames || new Set(),
             });
@@ -1947,8 +1734,8 @@ function initializeFederationFactory(subgraphs) {
             concreteTypeNamesByAbstractTypeName,
             entityDataByTypeName,
             entityInterfaceFederationDataByTypeName,
-            graph,
             internalSubgraphBySubgraphName,
+            internalGraph,
             warnings,
         }),
     };