@wundergraph/composition 0.15.0 → 0.17.0

package/dist/federation/federation-factory.js

@@ -15,20 +15,23 @@ 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 {
+    authorizationDataByParentTypeName;
     abstractToConcreteTypeNames = new Map();
     areFieldsExternal = false;
     areFieldsShareable = false;
     argumentTypeNameSet = new Set();
-    argumentConfigurations = [];
+    fieldConfigurationByFieldPath = new Map();
     entityInterfaceFederationDataByTypeName;
     executableDirectives = new Set();
     parentTypeName = '';
     persistedDirectives = new Set([string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG]);
+    persistedDirectiveDefinitions = new Set([string_constants_1.AUTHENTICATED, string_constants_1.DEPRECATED, string_constants_1.INACCESSIBLE, string_constants_1.TAG, string_constants_1.REQUIRES_SCOPES]);
     currentSubgraphName = '';
     childName = '';
     directiveDefinitions = new Map();
-    entities = new Map();
+    entityContainersByTypeName;
     errors = [];
     evaluatedObjectLikesBySubgraph = new Map();
     extensions = new Map();
@@ -46,36 +49,24 @@ class FederationFactory {
     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;
+    renamedTypeNameByOriginalTypeName = new Map();
     warnings;
-    constructor(subgraphs, subgraphConfigBySubgraphName, entityInterfaceFederationDataByTypeName, warnings) {
-        this.subgraphs = subgraphs;
-        this.subgraphConfigBySubgraphName = subgraphConfigBySubgraphName;
+    constructor(authorizationDataByParentTypeName, entityContainersByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings) {
+        this.authorizationDataByParentTypeName = authorizationDataByParentTypeName;
+        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) {
@@ -238,7 +229,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 +266,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 +274,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 +300,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 +322,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 +330,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);
@@ -385,7 +376,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 +456,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 +468,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 +517,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 +526,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 +548,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 +558,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 +588,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 +602,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 +727,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 +755,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);
@@ -782,11 +773,30 @@ class FederationFactory {
         directiveContainer.node.arguments = args;
         definitions.push(directiveContainer.node);
     }
+    pushAuthorizationDirectives(fieldContainer, parentTypeName) {
+        const authorizationData = this.authorizationDataByParentTypeName.get(parentTypeName);
+        if (!authorizationData) {
+            return;
+        }
+        const fieldAuthorizationData = authorizationData.fieldAuthorizationDataByFieldName.get(fieldContainer.node.name.value);
+        if (!fieldAuthorizationData) {
+            return;
+        }
+        if (fieldAuthorizationData.requiresAuthentication) {
+            fieldContainer.directives.directives.set(string_constants_1.AUTHENTICATED, [(0, utils_3.generateAuthenticatedDirective)()]);
+        }
+        if (fieldAuthorizationData.requiredScopes.length > 0) {
+            fieldContainer.directives.directives.set(string_constants_1.REQUIRES_SCOPES, [
+                (0, utils_3.generateRequiresScopesDirective)(fieldAuthorizationData.requiredScopes),
+            ]);
+        }
+    }
     getMergedFieldDefinitionNode(fieldContainer, parentTypeName) {
-        if (!fieldContainer.arguments) {
+        this.pushAuthorizationDirectives(fieldContainer, parentTypeName);
+        (0, utils_1.pushPersistedDirectivesAndGetNode)(fieldContainer);
+        if (fieldContainer.arguments.size < 1) {
             return fieldContainer.node;
         }
-        (0, utils_1.pushPersistedDirectivesAndGetNode)(fieldContainer);
         const fieldName = fieldContainer.node.name.value;
         const fieldPath = `${parentTypeName}.${fieldName}`;
         const args = [];
@@ -797,7 +807,7 @@ class FederationFactory {
             this.errors.push((0, errors_1.invalidRequiredArgumentsError)(string_constants_1.FIELD, fieldPath, errors));
         }
         else if (argumentNames.length > 0) {
-            this.argumentConfigurations.push({
+            this.fieldConfigurationByFieldPath.set(`${parentTypeName}.${fieldName}`, {
                 argumentNames,
                 fieldName,
                 typeName: parentTypeName,
@@ -883,7 +893,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 +916,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 +944,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 +978,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 +1001,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 +1009,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 +1017,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,22 +1050,171 @@ 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;
+        }
+    }
+    handleAuthorizationDataForRenamedTypes() {
+        for (const [originalTypeName, renamedTypeName] of this.renamedTypeNameByOriginalTypeName) {
+            const originalAuthorizationData = this.authorizationDataByParentTypeName.get(originalTypeName);
+            if (!originalAuthorizationData) {
+                continue;
+            }
+            originalAuthorizationData.typeName = renamedTypeName;
+            const renamedAuthorizationData = this.authorizationDataByParentTypeName.get(renamedTypeName);
+            if (!renamedAuthorizationData) {
+                this.authorizationDataByParentTypeName.set(renamedTypeName, originalAuthorizationData);
+            }
+            else {
+                (0, utils_3.addAuthorizationDataProperties)(originalAuthorizationData, renamedAuthorizationData);
+            }
+            this.authorizationDataByParentTypeName.delete(originalTypeName);
+        }
+    }
     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.keyFieldNamesByParentTypeName = subgraph.keyFieldNamesByParentTypeName;
             (0, subgraph_1.walkSubgraphToFederate)(subgraph.definitions, subgraph.overriddenFieldNamesByParentTypeName, factory);
         }
+        this.handleAuthorizationDataForRenamedTypes();
         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');
@@ -1064,7 +1223,7 @@ class FederationFactory {
                 continue;
             }
             for (const subgraphName of entityInterfaceData.interfaceObjectSubgraphs) {
-                const configurationDataMap = (0, utils_3.getOrThrowError)(this.subgraphConfigBySubgraphName, subgraphName, 'subgraphConfigBySubgraphName').configurationDataMap;
+                const configurationDataMap = (0, utils_3.getOrThrowError)(this.internalSubgraphBySubgraphName, subgraphName, 'internalSubgraphBySubgraphName').configurationDataMap;
                 const concreteTypeNames = this.abstractToConcreteTypeNames.get(typeName);
                 if (!concreteTypeNames) {
                     continue;
@@ -1087,10 +1246,10 @@ class FederationFactory {
                         continue;
                     }
                     // The subgraph locations of the interface object must be added to the concrete types that implement it
-                    const entity = this.entities.get(concreteTypeName);
+                    const entity = this.entityContainersByTypeName.get(concreteTypeName);
                     if (entity) {
                         // TODO error if not an entity
-                        entity.subgraphs.add(subgraphName);
+                        entity.subgraphNames.add(subgraphName);
                     }
                     const configurationData = {
                         fieldNames,
@@ -1113,13 +1272,16 @@ class FederationFactory {
         }
         const definitions = [];
         for (const [directiveName, directiveContainer] of this.directiveDefinitions) {
-            if (this.persistedDirectives.has(directiveName)) {
+            if (this.persistedDirectiveDefinitions.has(directiveName)) {
                 definitions.push(directiveContainer.node);
                 continue;
             }
-            // The definitions must be present in all subgraphs to kept in the federated graph
+            // The definitions must be present in all subgraphs to be kept in the federated graph
             this.addValidExecutableDirectiveDefinition(directiveName, directiveContainer, definitions);
         }
+        if (this.directiveDefinitions.has(string_constants_1.REQUIRES_SCOPES)) {
+            definitions.push(constants_1.SCOPE_SCALAR_DEFINITION);
+        }
         for (const [typeName, extension] of this.extensions) {
             this.parentTypeName = typeName;
             if (extension.isRootType && !this.parents.has(typeName)) {
@@ -1144,7 +1306,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);
@@ -1166,8 +1328,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 = [];
@@ -1299,7 +1460,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);
@@ -1309,7 +1470,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:
@@ -1320,12 +1481,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)));
@@ -1340,10 +1501,20 @@ 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,
+            });
+        }
+        for (const authorizationData of this.authorizationDataByParentTypeName.values()) {
+            (0, utils_3.upsertAuthorizationConfiguration)(this.fieldConfigurationByFieldPath, authorizationData);
+        }
         return {
             federationResult: {
-                argumentConfigurations: this.argumentConfigurations,
-                subgraphConfigBySubgraphName: this.subgraphConfigBySubgraphName,
+                fieldConfigurations: Array.from(this.fieldConfigurationByFieldPath.values()),
+                subgraphConfigBySubgraphName,
                 federatedGraphAST: newAst,
                 federatedGraphSchema: (0, graphql_1.buildASTSchema)(newAst),
             },
@@ -1356,21 +1527,14 @@ function federateSubgraphs(subgraphs) {
     if (subgraphs.length < 1) {
         return { errors: [errors_1.minimumSubgraphRequirementError] };
     }
-    const { errors, internalSubgraphsBySubgraphName, warnings } = (0, normalization_factory_1.batchNormalize)(subgraphs);
+    const { authorizationDataByParentTypeName, entityContainerByTypeName, errors, internalSubgraphBySubgraphName, warnings, } = (0, normalization_factory_1.batchNormalize)(subgraphs);
     if (errors) {
         return { errors };
     }
-    const internalSubgraphs = [];
-    const subgraphConfigBySubgraphName = new Map();
     const entityInterfaceFederationDataByTypeName = new Map();
     const invalidEntityInterfacesByTypeName = new Map();
     const validEntityInterfaceTypeNames = new Set();
-    for (const [subgraphName, internalSubgraph] of internalSubgraphsBySubgraphName) {
-        internalSubgraphs.push(internalSubgraph);
-        subgraphConfigBySubgraphName.set(subgraphName, {
-            configurationDataMap: internalSubgraph.configurationDataMap,
-            schema: internalSubgraph.schema,
-        });
+    for (const [subgraphName, internalSubgraph] of internalSubgraphBySubgraphName) {
         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
@@ -1402,8 +1566,7 @@ function federateSubgraphs(subgraphs) {
             ],
         };
     }
-    const federationFactory = new FederationFactory(internalSubgraphs, subgraphConfigBySubgraphName, entityInterfaceFederationDataByTypeName, warnings);
-    return federationFactory.federate();
+    return new FederationFactory(authorizationDataByParentTypeName, entityContainerByTypeName, entityInterfaceFederationDataByTypeName, internalSubgraphBySubgraphName, warnings).federate();
 }
 exports.federateSubgraphs = federateSubgraphs;
 //# sourceMappingURL=federation-factory.js.map