@wundergraph/composition 0.14.0 → 0.16.0

package/dist/federation/federation-factory.js

@@ -15,20 +15,21 @@ const merge_1 = require("@graphql-tools/merge");
 const constants_1 = require("../utils/constants");
 const normalization_factory_1 = require("../normalization/normalization-factory");
 const utils_4 = require("../normalization/utils");
+const index_1 = require("graphql/index");
 class FederationFactory {
     abstractToConcreteTypeNames = new Map();
     areFieldsExternal = false;
     areFieldsShareable = false;
     argumentTypeNameSet = new Set();
     argumentConfigurations = [];
-    entityInterfaceDatasByTypeName;
+    entityInterfaceFederationDataByTypeName;
     executableDirectives = new Set();
     parentTypeName = '';
     persistedDirectives = new Set([string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG]);
     currentSubgraphName = '';
     childName = '';
     directiveDefinitions = new Map();
-    entities = new Map();
+    entityContainersByTypeName;
     errors = [];
     evaluatedObjectLikesBySubgraph = new Map();
     extensions = new Map();
@@ -42,40 +43,26 @@ class FederationFactory {
     isCurrentParentExtensionType = false;
     isParentRootType = false;
     isParentInputObject = false;
-    keyFieldsByParentTypeName = new Map();
+    keyFieldNamesByParentTypeName = new Map();
     outputFieldTypeNameSet = new Set();
     parents = new Map();
     rootTypeNames = new Set([string_constants_1.DEFAULT_MUTATION, string_constants_1.DEFAULT_QUERY, string_constants_1.DEFAULT_SUBSCRIPTION]);
-    subgraphs = [];
+    internalSubgraphBySubgraphName;
     shareableErrorTypeNames = new Map();
-    subgraphConfigBySubgraphName;
     warnings;
-    constructor(subgraphs, subgraphConfigBySubgraphName, entityInterfaceDatasByTypeName, warnings) {
-        this.subgraphs = subgraphs;
-        this.subgraphConfigBySubgraphName = subgraphConfigBySubgraphName;
-        this.entityInterfaceDatasByTypeName = entityInterfaceDatasByTypeName;
+    constructor(entityContainersByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings) {
+        this.entityContainersByTypeName = entityContainersByTypeName;
+        this.entityInterfaceFederationDataByTypeName = entityInterfaceFederationDataByTypeName;
+        this.internalSubgraphBySubgraphName = internalSubgraphBySubgraphName;
         this.warnings = warnings || [];
     }
     isObjectRootType(node) {
         return this.rootTypeNames.has(node.name.value);
     }
-    upsertEntity(node) {
-        const typeName = node.name.value;
-        const entity = this.entities.get(typeName);
-        if (entity) {
-            entity.subgraphs.add(this.currentSubgraphName);
-            return;
-        }
-        this.entities.set(typeName, {
-            fields: new Set(),
-            subgraphs: new Set([this.currentSubgraphName]),
-        });
-    }
     populateMultiGraphAndRenameOperations(subgraphs) {
-        for (const subgraph of subgraphs) {
+        for (const subgraph of subgraphs.values()) {
             this.currentSubgraphName = subgraph.name;
             (0, subgraph_1.walkSubgraphToCollectObjectLikesAndDirectiveDefinitions)(this, subgraph);
-            (0, subgraph_1.walkSubgraphToCollectFields)(this, subgraph);
         }
     }
     getEnumMergeMethod(enumName) {
@@ -112,7 +99,7 @@ class FederationFactory {
                 break;
             case graphql_1.Kind.OBJECT:
                 break;
-            // BOOLEAN, ENUM, FLOAT, INT, and STRING purposely fall through
+            // BOOLEAN, ENUM, FLOAT, INT, and STRING intentionally fall through
             case graphql_1.Kind.BOOLEAN:
             case graphql_1.Kind.ENUM:
             case graphql_1.Kind.FLOAT:
@@ -229,7 +216,7 @@ class FederationFactory {
         return argumentMap;
     }
     isFieldEntityKey() {
-        const parent = this.keyFieldsByParentTypeName.get(this.parentTypeName);
+        const parent = this.keyFieldNamesByParentTypeName.get(this.parentTypeName);
         if (parent) {
             return parent.has(this.childName);
         }
@@ -238,7 +225,7 @@ class FederationFactory {
     isFieldExternal(node) {
         return this.areFieldsExternal || (0, utils_1.isNodeExternal)(node);
     }
-    isFieldShareable(node, parent) {
+    isFieldShareable(node) {
         return (!this.isCurrentSubgraphVersionTwo || this.areFieldsShareable || this.isFieldEntityKey() || (0, utils_1.isNodeShareable)(node));
     }
     getOverrideTargetSubgraphName(node) {
@@ -275,7 +262,7 @@ class FederationFactory {
             this.upsertArguments(node, directiveDefinition.arguments);
             (0, utils_1.setLongestDescriptionForNode)(directiveDefinition.node, node.description);
             directiveDefinition.node.repeatable = directiveDefinition.node.repeatable && node.repeatable;
-            directiveDefinition.subgraphs.add(this.currentSubgraphName);
+            directiveDefinition.subgraphNames.add(this.currentSubgraphName);
             return;
         }
         const executableLocations = (0, utils_1.extractExecutableDirectiveLocations)(node.locations, new Set());
@@ -283,7 +270,7 @@ class FederationFactory {
             arguments: this.upsertArguments(node, new Map()),
             executableLocations,
             node: (0, ast_1.directiveDefinitionNodeToMutable)(node),
-            subgraphs: new Set([this.currentSubgraphName]),
+            subgraphNames: new Set([this.currentSubgraphName]),
         });
         if (executableLocations.size > 0) {
             this.executableDirectives.add(directiveName);
@@ -309,8 +296,8 @@ class FederationFactory {
             }
             // shareability doesn't matter if:
             // the field has only been seen exactly twice—the target override and the source override
-            if (fieldContainer.subgraphs.size === 2 &&
-                fieldContainer.subgraphs.has(fieldContainer.overrideTargetSubgraphName)) {
+            if (fieldContainer.subgraphNames.size === 2 &&
+                fieldContainer.subgraphNames.has(fieldContainer.overrideTargetSubgraphName)) {
                 continue;
             }
             unshareableFields += 1;
@@ -331,7 +318,7 @@ class FederationFactory {
         }
         const fieldMap = parent.fields;
         const isFieldExternal = this.isFieldExternal(node);
-        const isFieldShareable = this.isFieldShareable(node, parent);
+        const isFieldShareable = this.isFieldShareable(node);
         const fieldPath = `${this.parentTypeName}.${this.childName}`;
         const fieldRootTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
         const existingFieldContainer = fieldMap.get(this.childName);
@@ -339,7 +326,7 @@ class FederationFactory {
         if (existingFieldContainer) {
             this.extractPersistedDirectives(node.directives || [], existingFieldContainer.directives);
             (0, utils_1.setLongestDescriptionForNode)(existingFieldContainer.node, node.description);
-            existingFieldContainer.subgraphs.add(this.currentSubgraphName);
+            existingFieldContainer.subgraphNames.add(this.currentSubgraphName);
             existingFieldContainer.overrideTargetSubgraphName = targetSubgraph;
             existingFieldContainer.subgraphsByShareable.set(this.currentSubgraphName, isFieldShareable);
             existingFieldContainer.subgraphsByExternal.set(this.currentSubgraphName, isFieldExternal);
@@ -364,7 +351,7 @@ class FederationFactory {
                 isFieldExternal ||
                 (existingFieldContainer.isShareable && isFieldShareable) ||
                 this.isShareabilityOfAllFieldInstancesValid(existingFieldContainer) ||
-                this.entityInterfaceDatasByTypeName.has(this.parentTypeName) // TODO handle shareability with interfaceObjects
+                this.entityInterfaceFederationDataByTypeName.has(this.parentTypeName) // TODO handle shareability with interfaceObjects
             ) {
                 return;
             }
@@ -385,7 +372,7 @@ class FederationFactory {
             node: (0, ast_1.fieldDefinitionNodeToMutable)(node, this.parentTypeName),
             namedTypeName: fieldRootTypeName,
             overrideTargetSubgraphName: targetSubgraph,
-            subgraphs: new Set([this.currentSubgraphName]),
+            subgraphNames: new Set([this.currentSubgraphName]),
             subgraphsByShareable: new Map([[this.currentSubgraphName, isFieldShareable]]),
             subgraphsByExternal: new Map([[this.currentSubgraphName, isFieldExternal]]),
         });
@@ -465,7 +452,7 @@ class FederationFactory {
             (0, utils_1.setLongestDescriptionForNode)(parent.node, node.description);
             this.extractPersistedDirectives(node.directives || [], parent.directives);
             (0, utils_1.extractInterfaces)(node, parent.interfaces);
-            parent.subgraphs.add(this.currentSubgraphName);
+            parent.subgraphNames.add(this.currentSubgraphName);
             return;
         }
         this.parents.set(parentTypeName, {
@@ -477,7 +464,7 @@ class FederationFactory {
                 ...node,
                 kind: graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
             }),
-            subgraphs: new Set([this.currentSubgraphName]),
+            subgraphNames: new Set([this.currentSubgraphName]),
         });
     }
     upsertParentNode(node) {
@@ -526,7 +513,7 @@ class FederationFactory {
                         throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
                     }
                     (0, utils_1.extractInterfaces)(node, parent.interfaces);
-                    parent.subgraphs.add(this.currentSubgraphName);
+                    parent.subgraphNames.add(this.currentSubgraphName);
                     return;
                 }
                 this.parents.set(parentTypeName, {
@@ -535,7 +522,7 @@ class FederationFactory {
                     interfaces: (0, utils_1.extractInterfaces)(node, new Set()),
                     kind: node.kind,
                     node: (0, ast_1.interfaceTypeDefinitionNodeToMutable)(node),
-                    subgraphs: new Set([this.currentSubgraphName]),
+                    subgraphNames: new Set([this.currentSubgraphName]),
                 });
                 return;
             case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
@@ -557,7 +544,7 @@ class FederationFactory {
                         throw (0, errors_1.incompatibleParentKindFatalError)(parentTypeName, node.kind, parent.kind);
                     }
                     (0, utils_1.extractInterfaces)(node, parent.interfaces);
-                    parent.subgraphs.add(this.currentSubgraphName);
+                    parent.subgraphNames.add(this.currentSubgraphName);
                     return;
                 }
                 this.parents.set(parentTypeName, {
@@ -567,7 +554,7 @@ class FederationFactory {
                     isRootType: this.isParentRootType,
                     kind: node.kind,
                     node: (0, ast_1.objectTypeDefinitionNodeToMutable)(node),
-                    subgraphs: new Set([this.currentSubgraphName]),
+                    subgraphNames: new Set([this.currentSubgraphName]),
                 });
                 return;
             case graphql_1.Kind.UNION_TYPE_DEFINITION:
@@ -597,7 +584,7 @@ class FederationFactory {
             if (extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                 throw (0, errors_1.incompatibleParentKindFatalError)(this.parentTypeName, graphql_1.Kind.OBJECT_TYPE_EXTENSION, extension.kind);
             }
-            extension.subgraphs.add(this.currentSubgraphName);
+            extension.subgraphNames.add(this.currentSubgraphName);
             (0, utils_1.extractInterfaces)(node, extension.interfaces);
             this.extractPersistedDirectives(node.directives || [], extension.directives);
             return;
@@ -611,7 +598,7 @@ class FederationFactory {
             isRootType: this.isParentRootType,
             kind: graphql_1.Kind.OBJECT_TYPE_EXTENSION,
             node: (0, ast_1.objectTypeExtensionNodeToMutable)(node),
-            subgraphs: new Set([this.currentSubgraphName]),
+            subgraphNames: new Set([this.currentSubgraphName]),
         });
     }
     isTypeValidImplementation(originalType, implementationType) {
@@ -736,7 +723,7 @@ class FederationFactory {
     }
     mergeArguments(container, args, errors, argumentNames) {
         for (const argumentContainer of container.arguments.values()) {
-            const missingSubgraphs = (0, utils_3.getEntriesNotInHashSet)(container.subgraphs, argumentContainer.subgraphs);
+            const missingSubgraphs = (0, utils_3.getEntriesNotInHashSet)(container.subgraphNames, argumentContainer.subgraphs);
             const argumentName = argumentContainer.node.name.value;
             if (missingSubgraphs.length > 0) {
                 // Required arguments must be defined in all subgraphs that define the field
@@ -764,7 +751,7 @@ class FederationFactory {
         if (!this.executableDirectives.has(directiveName)) {
             return;
         }
-        if (this.subgraphs.length !== directiveContainer.subgraphs.size) {
+        if (this.internalSubgraphBySubgraphName.size !== directiveContainer.subgraphNames.size) {
             return;
         }
         directiveContainer.node.locations = (0, utils_1.setToNameNodeArray)(directiveContainer.executableLocations);
@@ -883,7 +870,7 @@ class FederationFactory {
                 return true;
             }
             if (entityAncestorName === parentTypeName) {
-                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entities, entityAncestorName, string_constants_1.ENTITIES).subgraphs);
+                const hasOverlap = (0, utils_3.doSetsHaveAnyOverlap)(fieldSubgraphs, (0, utils_3.getOrThrowError)(this.entityContainersByTypeName, entityAncestorName, string_constants_1.ENTITIES).subgraphNames);
                 this.graphPaths.set(path, hasOverlap);
                 return hasOverlap;
             }
@@ -906,7 +893,7 @@ class FederationFactory {
         return false;
     }
     isFieldExternalInAllMutualSubgraphs(subgraphs, fieldContainer) {
-        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(subgraphs, fieldContainer.subgraphs);
+        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(subgraphs, fieldContainer.subgraphNames);
         if (mutualSubgraphs.size < 1) {
             return false;
         }
@@ -934,7 +921,7 @@ class FederationFactory {
         }
         for (const entityAncestor of entityAncestors) {
             const entityContainer = (0, utils_3.getOrThrowError)(this.parents, entityAncestor, string_constants_1.PARENTS);
-            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, entityContainer.subgraphs);
+            const mutualEntityAncestorRootTypeFieldSubgraphs = (0, utils_3.getAllMutualEntries)(rootTypeFieldSubgraphs, entityContainer.subgraphNames);
             const mutualEntityAncestorSubgraphs = (0, utils_3.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
             for (const mutualSubgraph of mutualEntityAncestorSubgraphs) {
                 const objects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
@@ -968,12 +955,12 @@ class FederationFactory {
             if (this.isFieldExternalInAllMutualSubgraphs(rootTypeFieldData.subgraphs, fieldContainer)) {
                 continue;
             }
-            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, parentContainer.subgraphs, entityAncestors, parentTypeName);
+            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, parentContainer.subgraphNames, entityAncestors, parentTypeName);
             evaluatedObjectLikes.add(parentTypeName);
-            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphs) ||
-                this.isFieldResolvableByEntityAncestor(entityAncestors, fieldContainer.subgraphs, parentTypeName);
+            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphNames) ||
+                this.isFieldResolvableByEntityAncestor(entityAncestors, fieldContainer.subgraphNames, parentTypeName);
             const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
-            const entity = this.entities.get(fieldNamedTypeName);
+            const entity = this.entityContainersByTypeName.get(fieldNamedTypeName);
             if (isFieldResolvable) {
                 // The base scalars are not in this.parentMap
                 if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
@@ -991,7 +978,7 @@ class FederationFactory {
                     case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors], fieldContainer.subgraphs);
+                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
                         continue;
                     default:
                         this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
@@ -999,7 +986,7 @@ class FederationFactory {
                 }
             }
             if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
-                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphs], newCurrentFieldPath, parentTypeName));
+                this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphNames], newCurrentFieldPath, parentTypeName));
                 continue;
             }
             const childContainer = (0, utils_3.getOrThrowError)(this.parents, fieldNamedTypeName, string_constants_1.PARENTS);
@@ -1007,21 +994,21 @@ class FederationFactory {
                 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, [...fieldContainer.subgraphs], newCurrentFieldPath, parentTypeName));
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.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, [...fieldContainer.subgraphs], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
+                    this.errors.push((0, errors_1.unresolvableFieldError)(rootTypeFieldData, fieldName, [...fieldContainer.subgraphNames], newCurrentFieldPath + string_constants_1.SELECTION_REPRESENTATION, parentTypeName));
                     continue;
                 default:
                     this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
             }
         }
     }
-    evaluateResolvabilityOfAbstractType(abstractTypeName, abstractKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, parentSubgraphs) {
+    evaluateResolvabilityOfAbstractType(abstractTypeName, abstractKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors) {
         if (evaluatedObjectLikes.has(abstractTypeName)) {
             return;
         }
@@ -1040,43 +1027,205 @@ class FederationFactory {
                 throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_3.kindToTypeString)(concreteParentContainer.kind));
             }
             // If the concrete type is unreachable through an inline fragment, it is not an error
-            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteParentContainer.subgraphs, rootTypeFieldData.subgraphs)) {
+            if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteParentContainer.subgraphNames, rootTypeFieldData.subgraphs)) {
                 continue;
             }
-            const entity = this.entities.get(concreteTypeName);
+            const entity = this.entityContainersByTypeName.get(concreteTypeName);
             this.evaluateResolvabilityOfObject(concreteParentContainer, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, evaluatedObjectLikes, entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
         }
     }
+    validateKeyFieldSetsForImplicitEntity(entityContainer) {
+        const internalSubgraph = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, this.currentSubgraphName, 'internalSubgraphBySubgraphName');
+        const parentContainerByTypeName = internalSubgraph.parentContainerByTypeName;
+        const extensionContainerByTypeName = internalSubgraph.extensionContainerByTypeName;
+        const implicitEntityContainer = parentContainerByTypeName.get(entityContainer.typeName) ||
+            extensionContainerByTypeName.get(entityContainer.typeName);
+        if (!implicitEntityContainer ||
+            (implicitEntityContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                implicitEntityContainer.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION)) {
+            throw (0, errors_1.incompatibleParentKindFatalError)(entityContainer.typeName, graphql_1.Kind.OBJECT_TYPE_DEFINITION, implicitEntityContainer?.kind || graphql_1.Kind.NULL);
+        }
+        const configurationData = (0, utils_3.getOrThrowError)(internalSubgraph.configurationDataMap, entityContainer.typeName, 'internalSubgraph.configurationDataMap');
+        const keyFieldNames = new Set();
+        const keys = [];
+        // Any errors in the field sets would be caught when evaluating the explicit entities, so they are ignored here
+        for (const fieldSet of entityContainer.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 parentContainers = [implicitEntityContainer];
+            const definedFields = [];
+            let currentDepth = -1;
+            let shouldDefineSelectionSet = true;
+            let shouldAddKeyFieldSet = true;
+            (0, index_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 index_1.BREAK;
+                    },
+                },
+                Field: {
+                    enter(node) {
+                        const parentContainer = parentContainers[currentDepth];
+                        const parentTypeName = parentContainer.name.value;
+                        // If an object-like was just visited, a selection set should have been entered
+                        if (shouldDefineSelectionSet) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                        const fieldName = node.name.value;
+                        const fieldPath = `${parentTypeName}.${fieldName}`;
+                        const fieldContainer = parentContainer.fields.get(fieldName);
+                        // undefined if the field does not exist on the parent
+                        if (!fieldContainer || fieldContainer.arguments.size || definedFields[currentDepth].has(fieldName)) {
+                            shouldAddKeyFieldSet = false;
+                            return index_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, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.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 childContainer = parentContainerByTypeName.get(namedTypeName) || extensionContainerByTypeName.get(namedTypeName);
+                        if (!childContainer) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                        if (childContainer.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                            childContainer.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                            shouldDefineSelectionSet = true;
+                            parentContainers.push(childContainer);
+                            return;
+                        }
+                        // interfaces and unions are invalid in a key directive
+                        if ((0, utils_1.isKindAbstract)(childContainer.kind)) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                    },
+                },
+                InlineFragment: {
+                    enter() {
+                        shouldAddKeyFieldSet = false;
+                        return index_1.BREAK;
+                    },
+                },
+                SelectionSet: {
+                    enter() {
+                        if (!shouldDefineSelectionSet) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                        currentDepth += 1;
+                        shouldDefineSelectionSet = false;
+                        if (currentDepth < 0 || currentDepth >= parentContainers.length) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                        definedFields.push(new Set());
+                    },
+                    leave() {
+                        if (shouldDefineSelectionSet) {
+                            shouldAddKeyFieldSet = false;
+                            return index_1.BREAK;
+                        }
+                        // Empty selection sets would be a parse error, so it is unnecessary to handle them
+                        currentDepth -= 1;
+                        parentContainers.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);
+            keys.push({
+                fieldName: '',
+                selectionSet: (0, utils_4.getNormalizedFieldSet)(documentNode),
+                disableEntityResolver: true,
+            });
+        }
+        if (keys.length > 0) {
+            configurationData.isRootNode = true;
+            configurationData.keys = keys;
+        }
+    }
     federate() {
-        this.populateMultiGraphAndRenameOperations(this.subgraphs);
+        this.populateMultiGraphAndRenameOperations(this.internalSubgraphBySubgraphName);
         const factory = this;
-        for (const subgraph of this.subgraphs) {
+        for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
             this.isCurrentSubgraphVersionTwo = subgraph.isVersionTwo;
             this.currentSubgraphName = subgraph.name;
-            this.keyFieldsByParentTypeName = subgraph.keyFieldsByParentTypeName;
+            this.keyFieldNamesByParentTypeName = subgraph.keyFieldNamesByParentTypeName;
             (0, subgraph_1.walkSubgraphToFederate)(subgraph.definitions, subgraph.overriddenFieldNamesByParentTypeName, factory);
         }
-        for (const [typeName, entityInterfaceData] of this.entityInterfaceDatasByTypeName) {
+        for (const [typeName, entityInterfaceData] of this.entityInterfaceFederationDataByTypeName) {
             (0, utils_3.subtractSourceSetFromTargetSet)(entityInterfaceData.interfaceFieldNames, entityInterfaceData.interfaceObjectFieldNames);
             const entityInterface = (0, utils_3.getOrThrowError)(this.parents, typeName, 'parents');
             if (entityInterface.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 // TODO error
                 continue;
             }
-            const concreteTypes = this.abstractToConcreteTypeNames.get(typeName) || [];
-            for (const concreteType of concreteTypes) {
-                const parentContainer = (0, utils_3.getOrThrowError)(this.parents, concreteType, 'parents');
-                if (parentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            for (const subgraphName of entityInterfaceData.interfaceObjectSubgraphs) {
+                const configurationDataMap = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataMap;
+                const concreteTypeNames = this.abstractToConcreteTypeNames.get(typeName);
+                if (!concreteTypeNames) {
                     continue;
                 }
-                for (const fieldName of entityInterfaceData.interfaceObjectFieldNames) {
-                    const existingFieldContainer = parentContainer.fields.get(fieldName);
-                    if (existingFieldContainer) {
-                        // TODO handle shareability
+                const interfaceObjectConfiguration = (0, utils_3.getOrThrowError)(configurationDataMap, typeName, 'configurationDataMap');
+                const keys = interfaceObjectConfiguration.keys;
+                if (!keys) {
+                    // error TODO no keys
+                    continue;
+                }
+                interfaceObjectConfiguration.entityInterfaceConcreteTypeNames = entityInterfaceData.concreteTypeNames;
+                const fieldNames = interfaceObjectConfiguration.fieldNames;
+                for (const concreteTypeName of concreteTypeNames) {
+                    if (configurationDataMap.has(concreteTypeName)) {
+                        // error TODO
                         continue;
                     }
-                    const interfaceFieldContainer = (0, utils_3.getOrThrowError)(entityInterface.fields, fieldName, 'entityInterface.fields');
-                    parentContainer.fields.set(fieldName, { ...interfaceFieldContainer });
+                    const concreteTypeContainer = (0, utils_3.getOrThrowError)(this.parents, concreteTypeName, 'parents');
+                    if (concreteTypeContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                        continue;
+                    }
+                    // The subgraph locations of the interface object must be added to the concrete types that implement it
+                    const entity = this.entityContainersByTypeName.get(concreteTypeName);
+                    if (entity) {
+                        // TODO error if not an entity
+                        entity.subgraphNames.add(subgraphName);
+                    }
+                    const configurationData = {
+                        fieldNames,
+                        isRootNode: true,
+                        keys,
+                        typeName: concreteTypeName,
+                    };
+                    for (const fieldName of entityInterfaceData.interfaceObjectFieldNames) {
+                        const existingFieldContainer = concreteTypeContainer.fields.get(fieldName);
+                        if (existingFieldContainer) {
+                            // TODO handle shareability
+                            continue;
+                        }
+                        const interfaceFieldContainer = (0, utils_3.getOrThrowError)(entityInterface.fields, fieldName, 'entityInterface.fields');
+                        concreteTypeContainer.fields.set(fieldName, { ...interfaceFieldContainer });
+                    }
+                    configurationDataMap.set(concreteTypeName, configurationData);
                 }
             }
         }
@@ -1113,7 +1262,7 @@ class FederationFactory {
                     this.childName = extensionFieldName;
                     this.upsertExtensionFieldArguments(extensionFieldContainer.arguments, baseFieldContainer.arguments);
                     (0, utils_1.setLongestDescriptionForNode)(baseFieldContainer.node, extensionFieldContainer.node.description);
-                    (0, utils_3.addIterableValuesToSet)(extensionFieldContainer.subgraphs, baseFieldContainer.subgraphs);
+                    (0, utils_3.addIterableValuesToSet)(extensionFieldContainer.subgraphNames, baseFieldContainer.subgraphNames);
                     continue;
                 }
                 const parent = this.shareableErrorTypeNames.get(typeName);
@@ -1135,8 +1284,7 @@ class FederationFactory {
             this.errors.push((0, errors_1.shareableFieldDefinitionsError)(parent, children));
         }
         const objectLikeContainersWithInterfaces = [];
-        for (const parentContainer of this.parents.values()) {
-            const parentTypeName = parentContainer.node.name.value;
+        for (const [parentTypeName, parentContainer] of this.parents) {
             switch (parentContainer.kind) {
                 case graphql_1.Kind.ENUM_TYPE_DEFINITION:
                     const values = [];
@@ -1268,7 +1416,7 @@ class FederationFactory {
                 if (evaluatedRootScalarsAndEnums.has(rootTypeFieldNamedTypeName)) {
                     continue;
                 }
-                if (!this.shouldEvaluateObjectLike(rootTypeFieldContainer.subgraphs, rootTypeFieldNamedTypeName)) {
+                if (!this.shouldEvaluateObjectLike(rootTypeFieldContainer.subgraphNames, rootTypeFieldNamedTypeName)) {
                     continue;
                 }
                 const childContainer = (0, utils_3.getOrThrowError)(this.parents, rootTypeFieldNamedTypeName, string_constants_1.PARENTS);
@@ -1278,7 +1426,7 @@ class FederationFactory {
                     fieldTypeNodeString: (0, merge_1.printTypeNode)(rootTypeFieldContainer.node.type),
                     path: fieldPath,
                     typeName: rootTypeName,
-                    subgraphs: rootTypeFieldContainer.subgraphs,
+                    subgraphs: rootTypeFieldContainer.subgraphNames,
                 };
                 switch (childContainer.kind) {
                     case graphql_1.Kind.ENUM_TYPE_DEFINITION:
@@ -1289,12 +1437,12 @@ class FederationFactory {
                         evaluatedRootScalarsAndEnums.add(rootTypeFieldNamedTypeName);
                         continue;
                     case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, new Set(), this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
+                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
                         continue;
                     case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(rootTypeFieldNamedTypeName, childContainer.kind, rootTypeFieldData, fieldPath, new Set(), this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : [], rootTypeFieldContainer.subgraphs);
+                        this.evaluateResolvabilityOfAbstractType(rootTypeFieldNamedTypeName, childContainer.kind, rootTypeFieldData, fieldPath, new Set(), this.entityContainersByTypeName.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
                         continue;
                     default:
                         this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
@@ -1309,10 +1457,17 @@ class FederationFactory {
             kind: graphql_1.Kind.DOCUMENT,
             definitions,
         };
+        const subgraphConfigBySubgraphName = new Map();
+        for (const subgraph of this.internalSubgraphBySubgraphName.values()) {
+            subgraphConfigBySubgraphName.set(subgraph.name, {
+                configurationDataMap: subgraph.configurationDataMap,
+                schema: subgraph.schema,
+            });
+        }
         return {
             federationResult: {
                 argumentConfigurations: this.argumentConfigurations,
-                subgraphConfigBySubgraphName: this.subgraphConfigBySubgraphName,
+                subgraphConfigBySubgraphName,
                 federatedGraphAST: newAst,
                 federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
             },
@@ -1325,31 +1480,46 @@ function federateSubgraphs(subgraphs) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError] };
     }
-    const { errors, internalSubgraphsBySubgraphName, warnings } = (0, normalization_factory_1.batchNormalize)(subgraphs);
+    const { entityContainerByTypeName, errors, internalSubgraphBySubgraphName, warnings } = (0, normalization_factory_1.batchNormalize)(subgraphs);
     if (errors) {
         return { errors };
     }
-    const internalSubgraphs = [];
-    const subgraphConfigBySubgraphName = new Map();
-    const entityInterfaceDatas = new Map();
-    for (const [subgraphName, internalSubgraph] of internalSubgraphsBySubgraphName) {
-        internalSubgraphs.push(internalSubgraph);
-        subgraphConfigBySubgraphName.set(subgraphName, {
-            configurationDataMap: internalSubgraph.configurationDataMap,
-            schema: internalSubgraph.schema,
-        });
+    const entityInterfaceFederationDataByTypeName = new Map();
+    const invalidEntityInterfacesByTypeName = new Map();
+    const validEntityInterfaceTypeNames = new Set();
+    for (const [subgraphName, internalSubgraph] of internalSubgraphBySubgraphName) {
         for (const [typeName, entityInterfaceData] of internalSubgraph.entityInterfaces) {
-            const existingDatas = entityInterfaceDatas.get(typeName);
-            if (!existingDatas) {
-                entityInterfaceDatas.set(typeName, (0, utils_3.newEntityInterfaceDatas)(entityInterfaceData, subgraphName));
+            // 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({
+                subgraphName,
+                concreteTypeNames: entityInterfaceData.concreteTypeNames || new Set(),
+            });
+            const existingData = entityInterfaceFederationDataByTypeName.get(typeName);
+            if (!existingData) {
+                validEntityInterfaceTypeNames.add(typeName);
+                entityInterfaceFederationDataByTypeName.set(typeName, (0, utils_3.newEntityInterfaceFederationData)(entityInterfaceData, subgraphName));
+                continue;
             }
-            else {
-                (0, utils_3.upsertEntityInterfaceDatas)(existingDatas, entityInterfaceData, subgraphName);
+            const areAnyImplementationsUndefined = (0, utils_3.upsertEntityInterfaceFederationData)(existingData, entityInterfaceData, subgraphName);
+            if (areAnyImplementationsUndefined) {
+                validEntityInterfaceTypeNames.delete(typeName);
             }
         }
     }
-    const federationFactory = new FederationFactory(internalSubgraphs, subgraphConfigBySubgraphName, entityInterfaceDatas, warnings);
-    return federationFactory.federate();
+    // Remove the valid entity interfaces type names so only genuinely invalid entity interfaces remain
+    for (const typeName of validEntityInterfaceTypeNames) {
+        invalidEntityInterfacesByTypeName.delete(typeName);
+    }
+    if (invalidEntityInterfacesByTypeName.size > 0) {
+        return {
+            errors: [
+                (0, errors_1.undefinedEntityInterfaceImplementationsError)(invalidEntityInterfacesByTypeName, entityInterfaceFederationDataByTypeName),
+            ],
+        };
+    }
+    return new FederationFactory(entityContainerByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings).federate();
 }
 exports.federateSubgraphs = federateSubgraphs;
 //# sourceMappingURL=federation-factory.js.map