@wundergraph/composition 0.6.0 → 0.6.2

package/dist/federation/federation-factory.js

@@ -16,6 +16,7 @@ const constants_1 = require("../utils/constants");
 const normalization_factory_1 = require("../normalization/normalization-factory");
 class FederationFactory {
     abstractToConcreteTypeNames = new Map();
+    areFieldsExternal = false;
     areFieldsShareable = false;
     argumentTypeNameSet = new Set();
     argumentConfigurations = [];
@@ -38,11 +39,13 @@ class FederationFactory {
     isCurrentParentExtensionType = false;
     isParentRootType = false;
     isParentInputObject = false;
+    keyFieldsByParentTypeName = 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 = [];
     shareableErrorTypeNames = new Map();
+    evaluatedObjectLikesBySubgraph = new Map();
     constructor(subgraphs) {
         this.subgraphs = subgraphs;
     }
@@ -70,12 +73,6 @@ class FederationFactory {
             (0, subgraph_1.walkSubgraphToCollectFields)(this, subgraph);
         }
     }
-    isFieldEntityKey(parent) {
-        if (parent.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || parent.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
-            return parent.entityKeys.has(this.childName);
-        }
-        return false;
-    }
     getEnumMergeMethod(enumName) {
         if (this.inputFieldTypeNameSet.has(enumName) || this.argumentTypeNameSet.has(enumName)) {
             if (this.outputFieldTypeNameSet.has(enumName)) {
@@ -141,6 +138,7 @@ class FederationFactory {
             const existingArgumentContainer = argumentMap.get(argName);
             if (!existingArgumentContainer) {
                 argumentMap.set(argName, {
+                    directives: this.extractPersistedDirectives(argumentNode.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     includeDefaultValue: !!argumentNode.defaultValue,
                     node: (0, ast_1.inputValueDefinitionNodeToMutable)(argumentNode, this.childName),
                     requiredSubgraphs: this.upsertRequiredSubgraph(new Set(), isRequired),
@@ -148,6 +146,7 @@ class FederationFactory {
                 });
                 continue;
             }
+            this.extractPersistedDirectives(argumentNode.directives || [], existingArgumentContainer.directives);
             (0, utils_1.setLongestDescriptionForNode)(existingArgumentContainer.node, argumentNode.description);
             this.upsertRequiredSubgraph(existingArgumentContainer.requiredSubgraphs, isRequired);
             existingArgumentContainer.subgraphs.add(this.currentSubgraphName);
@@ -165,11 +164,22 @@ class FederationFactory {
         }
         return argumentMap;
     }
+    isFieldEntityKey() {
+        const parent = this.keyFieldsByParentTypeName.get(this.parentTypeName);
+        if (parent) {
+            return parent.has(this.childName);
+        }
+        return false;
+    }
+    isFieldExternal(node) {
+        return this.areFieldsExternal || (0, utils_1.isNodeExternal)(node);
+    }
     isFieldShareable(node, parent) {
-        return (!this.isCurrentSubgraphVersionTwo ||
-            this.areFieldsShareable ||
-            (0, utils_1.isNodeShareable)(node) ||
-            (this.isCurrentParentEntity && this.isFieldEntityKey(parent)));
+        return (!this.isCurrentSubgraphVersionTwo
+            || this.areFieldsShareable
+            || this.isFieldEntityKey()
+            || (0, utils_1.isNodeShareable)(node)
+            || (0, utils_1.isNodeOverridden)(node));
     }
     upsertDirectiveNode(node) {
         const directiveName = node.name.value;
@@ -199,6 +209,27 @@ class FederationFactory {
             this.executableDirectives.add(directiveName);
         }
     }
+    areAllFieldInstancesExternalOrShareable(fieldContainer) {
+        let shareableFields = 0;
+        let unshareableFields = 0;
+        for (const [subgraphName, isShareable] of fieldContainer.subgraphsByShareable) {
+            if (isShareable) {
+                shareableFields += 1;
+                if (shareableFields && unshareableFields) {
+                    return false;
+                }
+                continue;
+            }
+            if (fieldContainer.subgraphsByExternal.get(subgraphName)) {
+                continue;
+            }
+            unshareableFields += 1;
+            if (shareableFields || unshareableFields > 1) {
+                return false;
+            }
+        }
+        return true;
+    }
     upsertFieldNode(node) {
         const parent = this.isCurrentParentExtensionType
             ? (0, utils_3.getOrThrowError)(this.extensions, this.parentTypeName, string_constants_1.EXTENSIONS)
@@ -209,6 +240,7 @@ class FederationFactory {
             throw (0, errors_1.unexpectedKindFatalError)(this.parentTypeName);
         }
         const fieldMap = parent.fields;
+        const isFieldExternal = this.isFieldExternal(node);
         const isFieldShareable = this.isFieldShareable(node, parent);
         const fieldPath = `${this.parentTypeName}.${this.childName}`;
         const fieldRootTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
@@ -218,6 +250,7 @@ class FederationFactory {
             (0, utils_1.setLongestDescriptionForNode)(existingFieldContainer.node, node.description);
             existingFieldContainer.subgraphs.add(this.currentSubgraphName);
             existingFieldContainer.subgraphsByShareable.set(this.currentSubgraphName, isFieldShareable);
+            existingFieldContainer.subgraphsByExternal.set(this.currentSubgraphName, isFieldExternal);
             const { typeErrors, typeNode } = (0, type_merging_1.getLeastRestrictiveMergedTypeNode)(existingFieldContainer.node.type, node.type, this.parentTypeName, this.childName);
             if (typeNode) {
                 existingFieldContainer.node.type = typeNode;
@@ -229,30 +262,38 @@ class FederationFactory {
                 this.errors.push((0, errors_1.incompatibleChildTypesError)(this.parentTypeName, this.childName, typeErrors[0], typeErrors[1]));
             }
             this.upsertArguments(node, existingFieldContainer.arguments);
-            // If the parent is not an interface and both fields are not shareable, is it is a shareable error
-            if (!this.isCurrentParentInterface && (!existingFieldContainer.isShareable || !isFieldShareable)) {
-                const shareableErrorTypeNames = this.shareableErrorTypeNames.get(this.parentTypeName);
-                if (shareableErrorTypeNames) {
-                    shareableErrorTypeNames.add(this.childName);
-                }
-                else {
-                    this.shareableErrorTypeNames.set(this.parentTypeName, new Set([this.childName]));
-                }
+            /* A field is valid if one of the following is true:
+              1. The field is an interface
+              2. The field is external
+              3. The existing fields AND the current field are ALL shareable
+              4. All other fields besides the current field are external
+            */
+            if (this.isCurrentParentInterface
+                || isFieldExternal
+                || (existingFieldContainer.isShareable && isFieldShareable)
+                || this.areAllFieldInstancesExternalOrShareable(existingFieldContainer)) {
+                return;
+            }
+            const shareableErrorTypeNames = this.shareableErrorTypeNames.get(this.parentTypeName);
+            if (shareableErrorTypeNames) {
+                shareableErrorTypeNames.add(this.childName);
             }
+            else {
+                this.shareableErrorTypeNames.set(this.parentTypeName, new Set([this.childName]));
+            }
+            // }
             return;
         }
         this.outputFieldTypeNameSet.add(fieldRootTypeName);
         fieldMap.set(this.childName, {
             arguments: this.upsertArguments(node, new Map()),
-            directives: this.extractPersistedDirectives(node.directives || [], {
-                directives: new Map(),
-                tags: new Map(),
-            }),
+            directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
             isShareable: isFieldShareable,
             node: (0, ast_1.fieldDefinitionNodeToMutable)(node, this.parentTypeName),
             namedTypeName: fieldRootTypeName,
             subgraphs: new Set([this.currentSubgraphName]),
             subgraphsByShareable: new Map([[this.currentSubgraphName, isFieldShareable]]),
+            subgraphsByExternal: new Map([[this.currentSubgraphName, isFieldExternal]]),
         });
     }
     upsertValueNode(node) {
@@ -276,10 +317,7 @@ class FederationFactory {
                 }
                 enumValues.set(this.childName, {
                     appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     node: (0, ast_1.enumValueDefinitionNodeToMutable)(node),
                 });
                 return;
@@ -314,10 +352,7 @@ class FederationFactory {
                 this.inputFieldTypeNameSet.add(inputValueNamedType);
                 inputValues.set(this.childName, {
                     appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     includeDefaultValue: !!node.defaultValue,
                     node: (0, ast_1.inputValueDefinitionNodeToMutable)(node, this.parentTypeName),
                 });
@@ -344,10 +379,7 @@ class FederationFactory {
                 }
                 this.parents.set(parentTypeName, {
                     appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     values: new Map(),
                     kind: node.kind,
                     node: (0, ast_1.enumTypeDefinitionNodeToMutable)(node),
@@ -363,10 +395,7 @@ class FederationFactory {
                 }
                 this.parents.set(parentTypeName, {
                     appearances: 1,
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     fields: new Map(),
                     kind: node.kind,
                     node: (0, ast_1.inputObjectTypeDefinitionNodeToMutable)(node),
@@ -384,10 +413,7 @@ class FederationFactory {
                 const nestedInterfaces = new Set();
                 (0, utils_1.extractInterfaces)(node, nestedInterfaces);
                 this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     fields: new Map(),
                     interfaces: nestedInterfaces,
                     kind: node.kind,
@@ -403,10 +429,7 @@ class FederationFactory {
                     return;
                 }
                 this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     kind: node.kind,
                     node: (0, ast_1.scalarTypeDefinitionNodeToMutable)(node),
                 });
@@ -426,10 +449,7 @@ class FederationFactory {
                 const entityKeys = new Set();
                 (0, utils_1.extractEntityKeys)(node, entityKeys, this.errors);
                 this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     fields: new Map(),
                     entityKeys,
                     interfaces,
@@ -452,10 +472,7 @@ class FederationFactory {
                     return;
                 }
                 this.parents.set(parentTypeName, {
-                    directives: this.extractPersistedDirectives(node.directives || [], {
-                        directives: new Map(),
-                        tags: new Map(),
-                    }),
+                    directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
                     kind: node.kind,
                     members: new Set(node.types?.map((member) => member.name.value)),
                     node: (0, ast_1.unionTypeDefinitionNodeToMutable)(node),
@@ -478,10 +495,7 @@ class FederationFactory {
         const interfaces = (0, utils_1.extractInterfaces)(node, new Set());
         const entityKeys = (0, utils_1.extractEntityKeys)(node, new Set(), this.errors);
         this.extensions.set(this.parentTypeName, {
-            directives: this.extractPersistedDirectives(node.directives || [], {
-                directives: new Map(),
-                tags: new Map(),
-            }),
+            directives: this.extractPersistedDirectives(node.directives || [], (0, utils_2.newPersistedDirectivesContainer)()),
             entityKeys,
             fields: new Map(),
             interfaces,
@@ -621,7 +635,7 @@ class FederationFactory {
                     errors.push({
                         argumentName,
                         missingSubgraphs,
-                        requiredSubgraphs: [...argumentContainer.requiredSubgraphs]
+                        requiredSubgraphs: [...argumentContainer.requiredSubgraphs],
                     });
                 }
                 // If the argument is always optional, but it's not defined in all subgraphs that define the field,
@@ -630,7 +644,7 @@ class FederationFactory {
             }
             argumentContainer.node.defaultValue = argumentContainer.includeDefaultValue
                 ? argumentContainer.node.defaultValue : undefined;
-            args.push(argumentContainer.node);
+            args.push((0, utils_1.pushPersistedDirectivesAndGetNode)(argumentContainer));
             if (argumentNames) {
                 argumentNames.push(argumentName);
             }
@@ -662,7 +676,7 @@ class FederationFactory {
         if (!fieldContainer.arguments) {
             return fieldContainer.node;
         }
-        (0, utils_1.pushPersistedDirectivesToNode)(fieldContainer);
+        (0, utils_1.pushPersistedDirectivesAndGetNode)(fieldContainer);
         const fieldName = fieldContainer.node.name.value;
         const fieldPath = `${parentTypeName}.${fieldName}`;
         const args = [];
@@ -676,12 +690,34 @@ class FederationFactory {
             this.argumentConfigurations.push({
                 argumentNames,
                 fieldName,
-                typeName: parentTypeName
+                typeName: parentTypeName,
             });
         }
         fieldContainer.node.arguments = args;
         return fieldContainer.node;
     }
+    // the deprecated directive with the longest reason is kept
+    upsertDeprecatedDirective(directive, deprecatedDirectiveContainer) {
+        if (!directive.arguments || directive.arguments.length < 1) {
+            deprecatedDirectiveContainer.directive = directive;
+            return;
+        }
+        if (directive.arguments.length !== 1) {
+            this.errors.push(errors_1.invalidDeprecatedDirectiveError);
+            return;
+        }
+        const reasonArgument = directive.arguments[0].value;
+        if (reasonArgument.kind !== graphql_1.Kind.STRING) {
+            this.errors.push(errors_1.invalidDeprecatedDirectiveError);
+            return;
+        }
+        if (deprecatedDirectiveContainer.reason
+            && reasonArgument.value.length < deprecatedDirectiveContainer.reason.length) {
+            return;
+        }
+        deprecatedDirectiveContainer.reason = reasonArgument.value;
+        deprecatedDirectiveContainer.directive = directive;
+    }
     // tags with the same name string are merged
     mergeTagDirectives(directive, map) {
         // the directive has been validated in the normalizer
@@ -705,6 +741,10 @@ class FederationFactory {
             if (!this.persistedDirectives.has(directiveName)) {
                 continue;
             }
+            if (directiveName == string_constants_1.DEPRECATED) {
+                this.upsertDeprecatedDirective(directive, container.deprecated);
+                continue;
+            }
             if (directiveName === string_constants_1.TAG) {
                 this.mergeTagDirectives(directive, container.tags);
                 continue;
@@ -723,13 +763,13 @@ class FederationFactory {
         }
         return container;
     }
-    entityAncestor(entityAncestors, fieldSubgraphs, parentTypeName) {
+    isFieldResolvableByEntityAncestor(entityAncestors, fieldSubgraphs, parentTypeName) {
         if (!this.graph.hasNode(parentTypeName)) {
             return false;
         }
         for (const entityAncestorName of entityAncestors) {
             const path = `${entityAncestorName}.${parentTypeName}`;
-            if (this.graphPaths.get(path)) {
+            if (entityAncestorName !== parentTypeName && this.graphPaths.get(path)) {
                 return true;
             }
             if (entityAncestorName === parentTypeName) {
@@ -745,11 +785,67 @@ class FederationFactory {
         }
         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;
+    }
+    isFieldExternalInAllMutualSubgraphs(subgraphs, fieldContainer) {
+        const mutualSubgraphs = (0, utils_3.getAllMutualEntries)(subgraphs, fieldContainer.subgraphs);
+        if (mutualSubgraphs.size < 1) {
+            return false;
+        }
+        for (const mutualSubgraph of mutualSubgraphs) {
+            const isExternal = fieldContainer.subgraphsByExternal.get(mutualSubgraph);
+            if (isExternal) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    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 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 mutualEntityAncestorSubgraphs = (0, utils_3.getAllMutualEntries)(mutualEntityAncestorRootTypeFieldSubgraphs, objectSubgraphs);
+            for (const mutualSubgraph of mutualEntityAncestorSubgraphs) {
+                const objects = this.evaluatedObjectLikesBySubgraph.get(mutualSubgraph);
+                if (objects) {
+                    objects.add(parentTypeName);
+                }
+                else {
+                    this.evaluatedObjectLikesBySubgraph.set(mutualSubgraph, new Set([parentTypeName]));
+                }
+            }
+        }
+    }
     evaluateResolvabilityOfObject(parentContainer, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, isParentAbstract = false) {
         const parentTypeName = parentContainer.node.name.value;
         if (evaluatedObjectLikes.has(parentTypeName)) {
             return;
         }
+        if (!this.shouldEvaluateObjectLike(rootTypeFieldData.subgraphs, parentTypeName)) {
+            evaluatedObjectLikes.add(parentTypeName);
+            return;
+        }
         for (const [fieldName, fieldContainer] of parentContainer.fields) {
             const fieldNamedTypeName = fieldContainer.namedTypeName;
             if (string_constants_1.ROOT_TYPES.has(fieldNamedTypeName)) {
@@ -759,10 +855,16 @@ class FederationFactory {
             if (evaluatedObjectLikes.has(fieldNamedTypeName)) {
                 continue;
             }
-            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphs);
+            if (this.isFieldExternalInAllMutualSubgraphs(rootTypeFieldData.subgraphs, fieldContainer)) {
+                continue;
+            }
+            this.updateEvaluatedSubgraphOccurrences(rootTypeFieldData.subgraphs, parentContainer.subgraphs, entityAncestors, parentTypeName);
+            evaluatedObjectLikes.add(parentTypeName);
+            const isFieldResolvable = (0, utils_3.doSetsHaveAnyOverlap)(rootTypeFieldData.subgraphs, fieldContainer.subgraphs)
+                || this.isFieldResolvableByEntityAncestor(entityAncestors, fieldContainer.subgraphs, parentTypeName);
             const newCurrentFieldPath = currentFieldPath + (isParentAbstract ? ' ' : '.') + fieldName;
             const entity = this.entities.get(fieldNamedTypeName);
-            if (isFieldResolvable || this.entityAncestor(entityAncestors, fieldContainer.subgraphs, parentTypeName)) {
+            if (isFieldResolvable) {
                 // The base scalars are not in this.parentMap
                 if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
                     continue;
@@ -774,12 +876,12 @@ class FederationFactory {
                     case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                         continue;
                     case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, newCurrentFieldPath, new Set([...evaluatedObjectLikes, parentTypeName]), entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
+                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors]);
                         continue;
                     case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     // intentional fallthrough
                     case graphql_1.Kind.UNION_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, new Set([...evaluatedObjectLikes, parentTypeName]), entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors], fieldContainer.subgraphs);
+                        this.evaluateResolvabilityOfAbstractType(fieldNamedTypeName, childContainer.kind, rootTypeFieldData, newCurrentFieldPath, evaluatedObjectLikes, entity ? [...entityAncestors, fieldNamedTypeName] : [...entityAncestors], fieldContainer.subgraphs);
                         continue;
                     default:
                         this.errors.push((0, errors_1.unexpectedObjectResponseType)(newCurrentFieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
@@ -809,13 +911,14 @@ class FederationFactory {
             }
         }
     }
-    evaluateResolvabilityOfAbstractType(fieldNamedTypeName, fieldNamedTypeKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, parentSubgraphs) {
-        if (evaluatedObjectLikes.has(fieldNamedTypeName)) {
+    evaluateResolvabilityOfAbstractType(abstractTypeName, abstractKind, rootTypeFieldData, currentFieldPath, evaluatedObjectLikes, entityAncestors, parentSubgraphs) {
+        if (evaluatedObjectLikes.has(abstractTypeName)) {
             return;
         }
-        const concreteTypeNames = this.abstractToConcreteTypeNames.get(fieldNamedTypeName);
+        evaluatedObjectLikes.add(abstractTypeName);
+        const concreteTypeNames = this.abstractToConcreteTypeNames.get(abstractTypeName);
         if (!concreteTypeNames) {
-            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(fieldNamedTypeKind), fieldNamedTypeName);
+            (0, errors_1.noConcreteTypesForAbstractTypeError)((0, utils_3.kindToTypeString)(abstractKind), abstractTypeName);
             return;
         }
         for (const concreteTypeName of concreteTypeNames) {
@@ -824,14 +927,14 @@ class FederationFactory {
             }
             const concreteParentContainer = (0, utils_3.getOrThrowError)(this.parents, concreteTypeName, string_constants_1.PARENTS);
             if (concreteParentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                // throw
-                continue;
+                throw (0, errors_1.unexpectedParentKindErrorMessage)(concreteTypeName, 'Object', (0, utils_3.kindToTypeString)(concreteParentContainer.kind));
             }
+            // If the concrete type is unreachable through the abstract type, it is not an error
             if (!(0, utils_3.doSetsHaveAnyOverlap)(concreteParentContainer.subgraphs, parentSubgraphs)) {
                 continue;
             }
             const entity = this.entities.get(concreteTypeName);
-            this.evaluateResolvabilityOfObject(concreteParentContainer, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, new Set([...evaluatedObjectLikes, fieldNamedTypeName]), entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
+            this.evaluateResolvabilityOfObject(concreteParentContainer, rootTypeFieldData, currentFieldPath + ` ... on ` + concreteTypeName, evaluatedObjectLikes, entity ? [...entityAncestors, concreteTypeName] : [...entityAncestors], true);
         }
     }
     federate() {
@@ -840,6 +943,7 @@ class FederationFactory {
         for (const subgraph of this.subgraphs) {
             this.isCurrentSubgraphVersionTwo = subgraph.isVersionTwo;
             this.currentSubgraphName = subgraph.name;
+            this.keyFieldsByParentTypeName = subgraph.keyFieldsByParentTypeName;
             (0, subgraph_1.walkSubgraphToFederate)(subgraph.definitions, factory);
         }
         const definitions = [];
@@ -900,7 +1004,7 @@ class FederationFactory {
                     const values = [];
                     const mergeMethod = this.getEnumMergeMethod(parentTypeName);
                     for (const enumValueContainer of parentContainer.values.values()) {
-                        (0, utils_1.pushPersistedDirectivesToNode)(enumValueContainer);
+                        (0, utils_1.pushPersistedDirectivesAndGetNode)(enumValueContainer);
                         switch (mergeMethod) {
                             case utils_2.MergeMethod.CONSISTENT:
                                 if (enumValueContainer.appearances < parentContainer.appearances) {
@@ -919,12 +1023,12 @@ class FederationFactory {
                         }
                     }
                     parentContainer.node.values = values;
-                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
+                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
                     break;
                 case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
                     const inputValues = [];
                     for (const inputValueContainer of parentContainer.fields.values()) {
-                        (0, utils_1.pushPersistedDirectivesToNode)(inputValueContainer);
+                        (0, utils_1.pushPersistedDirectivesAndGetNode)(inputValueContainer);
                         if (parentContainer.appearances === inputValueContainer.appearances) {
                             inputValues.push(inputValueContainer.node);
                         }
@@ -934,7 +1038,7 @@ class FederationFactory {
                         }
                     }
                     parentContainer.node.fields = inputValues;
-                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
+                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
                     break;
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                     const interfaceFields = [];
@@ -942,7 +1046,7 @@ class FederationFactory {
                         interfaceFields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
                     }
                     parentContainer.node.fields = interfaceFields;
-                    (0, utils_1.pushPersistedDirectivesToNode)(parentContainer);
+                    (0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer);
                     // Interface implementations can only be evaluated after they've been fully merged
                     if (parentContainer.interfaces.size > 0) {
                         objectLikeContainersWithInterfaces.push(parentContainer);
@@ -957,7 +1061,7 @@ class FederationFactory {
                         fields.push(this.getMergedFieldDefinitionNode(fieldContainer, parentTypeName));
                     }
                     parentContainer.node.fields = fields;
-                    (0, utils_1.pushPersistedDirectivesToNode)(parentContainer);
+                    (0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer);
                     // Interface implementations can only be evaluated after they've been fully merged
                     if (parentContainer.interfaces.size > 0) {
                         objectLikeContainersWithInterfaces.push(parentContainer);
@@ -967,7 +1071,7 @@ class FederationFactory {
                     }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
+                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
                     break;
                 case graphql_1.Kind.UNION_TYPE_DEFINITION:
                     const types = [];
@@ -975,7 +1079,7 @@ class FederationFactory {
                         types.push((0, utils_1.stringToNamedTypeNode)(memberName));
                     }
                     parentContainer.node.types = types;
-                    definitions.push((0, utils_1.getNodeWithPersistedDirectives)(parentContainer));
+                    definitions.push((0, utils_1.pushPersistedDirectivesAndGetNode)(parentContainer));
                     break;
             }
         }
@@ -995,11 +1099,18 @@ class FederationFactory {
             if (!rootTypeContainer || rootTypeContainer.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 evaluatedNamedTypes = new Set(constants_1.BASE_SCALARS);
+            const evaluatedRootScalarsAndEnums = new Set(constants_1.BASE_SCALARS);
             for (const [rootTypeFieldName, rootTypeFieldContainer] of rootTypeContainer.fields) {
                 const rootTypeFieldNamedTypeName = rootTypeFieldContainer.namedTypeName;
-                if (evaluatedNamedTypes.has(rootTypeFieldNamedTypeName)) {
+                if (evaluatedRootScalarsAndEnums.has(rootTypeFieldNamedTypeName)) {
+                    continue;
+                }
+                if (!this.shouldEvaluateObjectLike(rootTypeFieldContainer.subgraphs, rootTypeFieldNamedTypeName)) {
                     continue;
                 }
                 const childContainer = (0, utils_3.getOrThrowError)(this.parents, rootTypeFieldNamedTypeName, string_constants_1.PARENTS);
@@ -1011,22 +1122,21 @@ class FederationFactory {
                     typeName: rootTypeName,
                     subgraphs: rootTypeFieldContainer.subgraphs,
                 };
-                const evaluatedObjectLikes = new Set();
                 switch (childContainer.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
-                        evaluatedNamedTypes.add(rootTypeFieldNamedTypeName);
+                        evaluatedRootScalarsAndEnums.add(rootTypeFieldNamedTypeName);
                         continue;
                     case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, evaluatedObjectLikes, this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : []);
+                        this.evaluateResolvabilityOfObject(childContainer, rootTypeFieldData, fieldPath, new Set(), this.entities.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, evaluatedObjectLikes, this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : [], rootTypeFieldContainer.subgraphs);
+                        this.evaluateResolvabilityOfAbstractType(rootTypeFieldNamedTypeName, childContainer.kind, rootTypeFieldData, fieldPath, new Set(), this.entities.has(rootTypeFieldNamedTypeName) ? [rootTypeFieldNamedTypeName] : [], rootTypeFieldContainer.subgraphs);
                         continue;
                     default:
                         this.errors.push((0, errors_1.unexpectedObjectResponseType)(fieldPath, (0, utils_3.kindToTypeString)(childContainer.kind)));
@@ -1045,7 +1155,7 @@ class FederationFactory {
                 argumentConfigurations: this.argumentConfigurations,
                 federatedGraphAST: newAst,
                 federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
-            }
+            },
         };
     }
 }
@@ -1079,6 +1189,7 @@ function federateSubgraphs(subgraphs) {
         }
         normalizedSubgraphs.push({
             definitions: normalizationResult.subgraphAST,
+            keyFieldsByParentTypeName: normalizationResult.keyFieldsByParentTypeName,
             isVersionTwo: normalizationResult.isVersionTwo,
             name,
             operationTypes: normalizationResult.operationTypes,