@wundergraph/composition 0.15.0 → 0.17.0

package/dist/normalization/normalization-factory.js

@@ -32,32 +32,34 @@ class NormalizationFactory {
     abstractToConcreteTypeNames = new Map();
     allDirectiveDefinitions = new Map();
     argumentName = '';
+    authorizationDataByParentTypeName = new Map();
     childName = '';
     configurationDataMap = new Map();
     customDirectiveDefinitions = new Map();
     errors = [];
-    entities = new Set();
+    entityContainerByTypeName = new Map();
     entityInterfaces = new Map();
-    extensions = new Map();
+    extensionContainerByTypeName = new Map();
     isCurrentParentExtension = false;
     isCurrentParentRootType = false;
     isSubgraphVersionTwo = false;
-    fieldSetsByParent = new Map();
+    fieldSetContainerByTypeName = new Map();
     handledRepeatedDirectivesByHostPath = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
     lastChildNodeKind = graphql_1.Kind.NULL;
+    leafTypeNamesWithAuthorizationDirectives = new Set();
     keyFieldNamesByParentTypeName = new Map();
     operationTypeNames = new Map();
-    parents = new Map();
+    parentContainerByTypeName = new Map();
     parentTypeName = '';
     parentsWithChildArguments = new Set();
     eventsConfigurations = new Map();
     overridesByTargetSubgraphName = new Map();
     schemaDefinition;
-    subgraphName;
     referencedDirectives = new Set();
     referencedTypeNames = new Set();
     warnings = [];
+    subgraphName;
     constructor(subgraphName) {
         for (const baseDirectiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
             this.allDirectiveDefinitions.set(baseDirectiveDefinition.name.value, baseDirectiveDefinition);
@@ -74,7 +76,7 @@ class NormalizationFactory {
         if (constants_1.BASE_SCALARS.has(namedType)) {
             return { hasUnhandledError: false, typeString: '' };
         }
-        const parentContainer = this.parents.get(namedType);
+        const parentContainer = this.parentContainerByTypeName.get(namedType);
         if (!parentContainer) {
             this.errors.push((0, errors_1.undefinedTypeError)(namedType));
             return { hasUnhandledError: false, typeString: '' };
@@ -138,6 +140,75 @@ class NormalizationFactory {
         }
         return map;
     }
+    extractDirectivesAndAuthorization(node, map) {
+        if (!node.directives) {
+            return map;
+        }
+        const authorizationDirectives = [];
+        for (const directive of node.directives) {
+            const directiveName = directive.name.value;
+            if (directiveName === string_constants_1.EXTENDS) {
+                continue;
+            }
+            if (directiveName === string_constants_1.AUTHENTICATED || directiveName === string_constants_1.REQUIRES_SCOPES) {
+                authorizationDirectives.push(directive);
+            }
+            const existingDirectives = map.get(directiveName);
+            if (existingDirectives) {
+                existingDirectives.push(directive);
+                continue;
+            }
+            map.set(directiveName, [directive]);
+        }
+        if (authorizationDirectives.length < 1) {
+            return map;
+        }
+        if (node.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION ||
+            node.kind === graphql_1.Kind.ENUM_TYPE_EXTENSION ||
+            node.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+            node.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
+            this.leafTypeNamesWithAuthorizationDirectives.add(this.parentTypeName);
+        }
+        const parentAuthorizationData = (0, utils_3.getValueOrDefault)(this.authorizationDataByParentTypeName, this.parentTypeName, () => (0, utils_3.newAuthorizationData)(this.parentTypeName));
+        const authorizationData = (0, utils_3.getAuthorizationDataToUpdate)(parentAuthorizationData, node, this.childName);
+        for (const directiveNode of authorizationDirectives) {
+            const directiveName = directiveNode.name.value;
+            if (directiveName === string_constants_1.AUTHENTICATED) {
+                authorizationData.requiresAuthentication = true;
+                continue;
+            }
+            if (!directiveNode.arguments || directiveNode.arguments.length !== 1) {
+                break;
+            }
+            const scopesArgument = directiveNode.arguments[0];
+            if (scopesArgument.name.value !== string_constants_1.SCOPES) {
+                break;
+            }
+            if (scopesArgument.value.kind !== graphql_1.Kind.LIST) {
+                break;
+            }
+            const orScopes = scopesArgument.value.values;
+            if (orScopes.length < 1) {
+                continue;
+            }
+            for (const scopes of orScopes) {
+                if (scopes.kind !== graphql_1.Kind.LIST) {
+                    return map;
+                }
+                const andScopes = new Set();
+                for (const scope of scopes.values) {
+                    if (scope.kind !== graphql_1.Kind.STRING) {
+                        return map;
+                    }
+                    andScopes.add(scope.value);
+                }
+                if (andScopes.size) {
+                    authorizationData.requiredScopes.push(andScopes);
+                }
+            }
+        }
+        return map;
+    }
     extractUniqueUnionMembers(members, map) {
         for (const member of members) {
             const name = member.name.value;
@@ -282,20 +353,20 @@ class NormalizationFactory {
     }
     handleObjectLikeExtension(node) {
         this.isCurrentParentExtension = true;
-        const extension = this.extensions.get(this.parentTypeName);
+        const extension = this.extensionContainerByTypeName.get(this.parentTypeName);
         const convertedKind = this.convertKindForExtension(node);
         if (extension) {
             if (extension.kind !== convertedKind) {
                 this.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
                 return false;
             }
-            this.extractDirectives(node, extension.directives);
+            this.extractDirectivesAndAuthorization(node, extension.directives);
             (0, utils_1.extractInterfaces)(node, extension.interfaces, this.errors);
             return;
         }
         const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-        this.extensions.set(this.parentTypeName, {
-            directives: this.extractDirectives(node, new Map()),
+        this.extensionContainerByTypeName.set(this.parentTypeName, {
+            directives: this.extractDirectivesAndAuthorization(node, new Map()),
             fields: new Map(),
             interfaces: (0, utils_1.extractInterfaces)(node, new Set(), this.errors),
             isEntity,
@@ -305,9 +376,13 @@ class NormalizationFactory {
         if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION || !isEntity) {
             return;
         }
-        this.entities.add(this.parentTypeName);
-        const fieldSets = (0, utils_3.getValueOrDefault)(this.fieldSetsByParent, this.parentTypeName, utils_2.newFieldSetContainer);
-        this.extractKeyFieldSets(node, fieldSets.keys);
+        const fieldSetContainer = (0, utils_3.getValueOrDefault)(this.fieldSetContainerByTypeName, this.parentTypeName, utils_2.newFieldSetContainer);
+        this.extractKeyFieldSets(node, fieldSetContainer);
+        (0, utils_3.upsertEntityContainerProperties)(this.entityContainerByTypeName, {
+            typeName: this.parentTypeName,
+            keyFieldSets: fieldSetContainer.keys,
+            ...(this.subgraphName ? { subgraphNames: [this.subgraphName] } : {}),
+        });
     }
     validateChildDirectives(child, hostPath) {
         const childKind = child.node.kind;
@@ -395,7 +470,8 @@ class NormalizationFactory {
             operationTypeNode === graphql_1.OperationTypeNode.MUTATION ||
             operationTypeNode === graphql_1.OperationTypeNode.SUBSCRIPTION);
     }
-    extractKeyFieldSets(node, rawFieldSets) {
+    extractKeyFieldSets(node, fieldSetContainer) {
+        const rawFieldSets = fieldSetContainer.keys;
         const parentTypeName = node.name.value;
         if (!node.directives?.length) {
             // This should never happen
@@ -414,6 +490,9 @@ class NormalizationFactory {
             for (const arg of directive.arguments) {
                 const argumentName = arg.name.value;
                 if (arg.name.value === string_constants_1.RESOLVABLE) {
+                    if (arg.value.kind === graphql_1.Kind.BOOLEAN && !arg.value.value) {
+                        fieldSetContainer.disableEntityResolver = true;
+                    }
                     continue;
                 }
                 if (arg.name.value !== string_constants_1.FIELDS) {
@@ -437,7 +516,7 @@ class NormalizationFactory {
         }
         const implementationErrorsMap = new Map();
         for (const interfaceName of container.interfaces) {
-            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parents, interfaceName, string_constants_1.PARENTS);
+            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parentContainerByTypeName, interfaceName, string_constants_1.PARENTS);
             if (interfaceContainer.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
                 throw (0, errors_1.incompatibleParentKindFatalError)(interfaceName, graphql_1.Kind.INTERFACE_TYPE_DEFINITION, interfaceContainer.kind);
             }
@@ -510,7 +589,7 @@ class NormalizationFactory {
             this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name.value, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
         }
     }
-    handleOverride(node, fieldName) {
+    handleOverride(node) {
         if (node.name.value !== string_constants_1.OVERRIDE) {
             return;
         }
@@ -652,7 +731,6 @@ class NormalizationFactory {
         after the visitor has visited the entire schema and the subgraph is known to be a V2 graph. Consequently,
         allDirectiveDefinitions cannot be used to check for duplicate definitions, and another set (below) is required */
         const definedDirectives = new Set();
-        let fieldName = '';
         const handledRootTypes = new Set();
         // Collect any renamed root types
         (0, graphql_1.visit)(document, {
@@ -718,7 +796,7 @@ class NormalizationFactory {
             Directive: {
                 enter(node) {
                     const name = node.name.value;
-                    factory.handleOverride(node, fieldName);
+                    factory.handleOverride(node);
                     if (constants_1.VERSION_TWO_DIRECTIVES.has(name)) {
                         factory.isSubgraphVersionTwo = true;
                         return false;
@@ -731,16 +809,17 @@ class NormalizationFactory {
             },
             EnumTypeDefinition: {
                 enter(node) {
-                    const name = node.name.value;
-                    if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
+                    const typeName = node.name.value;
+                    if (factory.parentContainerByTypeName.has(typeName)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), typeName));
                         return false;
                     }
-                    factory.parentTypeName = name;
+                    factory.parentTypeName = typeName;
                     factory.lastParentNodeKind = node.kind;
-                    factory.parents.set(name, {
+                    const directives = factory.extractDirectivesAndAuthorization(node, new Map());
+                    factory.parentContainerByTypeName.set(typeName, {
                         description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
+                        directives,
                         kind: node.kind,
                         name: node.name,
                         values: new Map(),
@@ -757,17 +836,17 @@ class NormalizationFactory {
                     factory.parentTypeName = name;
                     factory.lastParentNodeKind = node.kind;
                     factory.isCurrentParentExtension = true;
-                    const extension = factory.extensions.get(factory.parentTypeName);
+                    const extension = factory.extensionContainerByTypeName.get(factory.parentTypeName);
                     if (extension) {
                         if (extension.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
                             factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
                             return false;
                         }
-                        factory.extractDirectives(node, extension.directives);
+                        factory.extractDirectivesAndAuthorization(node, extension.directives);
                         return;
                     }
-                    factory.extensions.set(name, {
-                        directives: factory.extractDirectives(node, new Map()),
+                    factory.extensionContainerByTypeName.set(name, {
+                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
                         kind: node.kind,
                         name: node.name,
                         values: new Map(),
@@ -785,8 +864,8 @@ class NormalizationFactory {
                     factory.childName = name;
                     factory.lastChildNodeKind = node.kind;
                     const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName, string_constants_1.PARENTS);
+                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
                     if (parent.kind !== graphql_1.Kind.ENUM_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.ENUM_TYPE_EXTENSION) {
                         throw (0, errors_1.unexpectedKindFatalError)(name);
                     }
@@ -810,39 +889,39 @@ class NormalizationFactory {
             },
             FieldDefinition: {
                 enter(node) {
-                    const name = node.name.value;
-                    if (factory.isCurrentParentRootType && (name === string_constants_1.SERVICE_FIELD || name === string_constants_1.ENTITIES_FIELD)) {
+                    const fieldName = node.name.value;
+                    if (factory.isCurrentParentRootType && (fieldName === string_constants_1.SERVICE_FIELD || fieldName === string_constants_1.ENTITIES_FIELD)) {
                         return false;
                     }
-                    factory.childName = name;
+                    factory.childName = fieldName;
                     factory.lastChildNodeKind = node.kind;
                     if (factory.canContainEventDirectives()) {
                         factory.extractEventDirectives(node);
                     }
-                    const fieldPath = `${factory.parentTypeName}.${name}`;
+                    const fieldPath = `${factory.parentTypeName}.${fieldName}`;
                     factory.lastChildNodeKind = node.kind;
                     const fieldNamedTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
                         factory.referencedTypeNames.add(fieldNamedTypeName);
                     }
                     const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName, string_constants_1.PARENTS);
+                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
                     if (parent.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
                         parent.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
                         parent.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION &&
                         parent.kind !== graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
                         throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
                     }
-                    if (parent.fields.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateFieldDefinitionError)(name, factory.parentTypeName));
+                    if (parent.fields.has(fieldName)) {
+                        factory.errors.push((0, errors_1.duplicateFieldDefinitionError)(fieldName, factory.parentTypeName));
                         return;
                     }
                     // recreate the node so the argument descriptions are updated
                     const fieldContainer = {
                         arguments: factory.extractArguments(node, new Map(), fieldPath),
-                        directives: factory.extractDirectives(node, new Map()),
-                        name,
+                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
+                        name: fieldName,
                         node: {
                             ...node,
                             arguments: node.arguments?.map((arg) => ({
@@ -851,27 +930,31 @@ class NormalizationFactory {
                             })),
                         },
                     };
-                    parent.fields.set(name, fieldContainer);
-                    // Only entities will have an existing FieldSet
-                    const existingFieldSet = factory.fieldSetsByParent.get(factory.parentTypeName);
-                    if (existingFieldSet) {
-                        // @requires should only be defined on a field whose parent is an entity
-                        // If there is existingFieldSet, it's an entity
-                        (0, utils_2.extractFieldSetValue)(name, existingFieldSet.requires, fieldContainer.directives.get(string_constants_1.REQUIRES));
-                        // @provides only makes sense on entities, but the field can be encountered before the type definition
-                        // When the FieldSet is evaluated, it will be checked whether the field is an entity.
-                        (0, utils_2.extractFieldSetValue)(name, existingFieldSet.provides, fieldContainer.directives.get(string_constants_1.PROVIDES));
-                        return;
+                    parent.fields.set(fieldName, fieldContainer);
+                    const entityContainer = factory.entityContainerByTypeName.get(factory.parentTypeName);
+                    if (entityContainer) {
+                        entityContainer.fieldNames.add(fieldName);
+                        // Only entities will have an existing FieldSet
+                        const existingFieldSet = factory.fieldSetContainerByTypeName.get(factory.parentTypeName);
+                        if (existingFieldSet) {
+                            // @requires should only be defined on a field whose parent is an entity
+                            // If there is existingFieldSet, it's an entity
+                            (0, utils_2.extractFieldSetValue)(fieldName, existingFieldSet.requires, fieldContainer.directives.get(string_constants_1.REQUIRES));
+                            // @provides only makes sense on entities, but the field can be encountered before the type definition
+                            // When the FieldSet is evaluated, it will be checked whether the field is an entity.
+                            (0, utils_2.extractFieldSetValue)(fieldName, existingFieldSet.provides, fieldContainer.directives.get(string_constants_1.PROVIDES));
+                            return;
+                        }
                     }
                     const providesDirectives = fieldContainer.directives.get(string_constants_1.PROVIDES);
                     // Check whether the directive exists to avoid creating unnecessary fieldSet configurations
                     if (!providesDirectives) {
                         return;
                     }
-                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetsByParent, factory.parentTypeName, utils_2.newFieldSetContainer);
+                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, factory.parentTypeName, utils_2.newFieldSetContainer);
                     // @provides only makes sense on entities, but the field can be encountered before the type definition
                     // When the FieldSet is evaluated, it will be checked whether the field is an entity.
-                    (0, utils_2.extractFieldSetValue)(name, fieldSetContainer.provides, providesDirectives);
+                    (0, utils_2.extractFieldSetValue)(fieldName, fieldSetContainer.provides, providesDirectives);
                 },
                 leave() {
                     factory.childName = '';
@@ -881,13 +964,13 @@ class NormalizationFactory {
             InputObjectTypeDefinition: {
                 enter(node) {
                     const name = node.name.value;
-                    if (factory.parents.has(name)) {
+                    if (factory.parentContainerByTypeName.has(name)) {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     factory.lastParentNodeKind = node.kind;
                     factory.parentTypeName = name;
-                    factory.parents.set(name, {
+                    factory.parentContainerByTypeName.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
@@ -906,7 +989,7 @@ class NormalizationFactory {
                     factory.parentTypeName = name;
                     factory.lastParentNodeKind = node.kind;
                     factory.isCurrentParentExtension = true;
-                    const extension = factory.extensions.get(factory.parentTypeName);
+                    const extension = factory.extensionContainerByTypeName.get(factory.parentTypeName);
                     if (extension) {
                         if (extension.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
                             factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
@@ -915,7 +998,7 @@ class NormalizationFactory {
                         factory.extractDirectives(node, extension.directives);
                         return;
                     }
-                    factory.extensions.set(name, {
+                    factory.extensionContainerByTypeName.set(name, {
                         directives: factory.extractDirectives(node, new Map()),
                         fields: new Map(),
                         kind: node.kind,
@@ -944,8 +1027,8 @@ class NormalizationFactory {
                         factory.referencedTypeNames.add(valueRootTypeName);
                     }
                     const parent = factory.isCurrentParentExtension
-                        ? (0, utils_3.getOrThrowError)(factory.extensions, factory.parentTypeName, string_constants_1.EXTENSIONS)
-                        : (0, utils_3.getOrThrowError)(factory.parents, factory.parentTypeName, string_constants_1.PARENTS);
+                        ? (0, utils_3.getOrThrowError)(factory.extensionContainerByTypeName, factory.parentTypeName, string_constants_1.EXTENSIONS)
+                        : (0, utils_3.getOrThrowError)(factory.parentContainerByTypeName, factory.parentTypeName, string_constants_1.PARENTS);
                     if (parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION && parent.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
                         throw (0, errors_1.unexpectedKindFatalError)(factory.parentTypeName);
                     }
@@ -976,23 +1059,14 @@ class NormalizationFactory {
                     if ((0, utils_1.isNodeExtension)(node)) {
                         return factory.handleObjectLikeExtension(node);
                     }
-                    if (factory.parents.has(name)) {
+                    if (factory.parentContainerByTypeName.has(name)) {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-                    if (isEntity) {
-                        factory.entityInterfaces.set(name, {
-                            concreteTypeNames: new Set(),
-                            interfaceFieldNames: new Set(node.fields?.map((field) => field.name.value)),
-                            interfaceObjectFieldNames: new Set(),
-                            isInterfaceObject: false,
-                            typeName: name,
-                        });
-                    }
-                    factory.parents.set(name, {
+                    factory.parentContainerByTypeName.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
+                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
                         fields: new Map(),
                         interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
                         isEntity,
@@ -1002,9 +1076,19 @@ class NormalizationFactory {
                     if (!isEntity) {
                         return;
                     }
-                    factory.entities.add(name);
-                    const fieldSets = (0, utils_3.getValueOrDefault)(factory.fieldSetsByParent, name, utils_2.newFieldSetContainer);
-                    factory.extractKeyFieldSets(node, fieldSets.keys);
+                    factory.entityInterfaces.set(name, {
+                        concreteTypeNames: new Set(),
+                        interfaceFieldNames: new Set(node.fields?.map((field) => field.name.value)),
+                        interfaceObjectFieldNames: new Set(),
+                        isInterfaceObject: false,
+                        typeName: name,
+                    });
+                    (0, utils_3.upsertEntityContainerProperties)(factory.entityContainerByTypeName, {
+                        typeName: factory.parentTypeName,
+                        ...(factory.subgraphName ? { subgraphNames: [factory.subgraphName] } : {}),
+                    });
+                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, name, utils_2.newFieldSetContainer);
+                    factory.extractKeyFieldSets(node, fieldSetContainer);
                 },
                 leave() {
                     factory.parentTypeName = '';
@@ -1026,12 +1110,12 @@ class NormalizationFactory {
             },
             ObjectTypeDefinition: {
                 enter(node) {
-                    const name = node.name.value;
-                    if (name === string_constants_1.SERVICE_OBJECT) {
+                    const typeName = node.name.value;
+                    if (typeName === string_constants_1.SERVICE_OBJECT) {
                         return false;
                     }
-                    factory.isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(name) || factory.operationTypeNames.has(name);
-                    factory.parentTypeName = name;
+                    factory.isCurrentParentRootType = string_constants_1.ROOT_TYPES.has(typeName) || factory.operationTypeNames.has(typeName);
+                    factory.parentTypeName = typeName;
                     factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForImplementedInterfaces)(node, factory.abstractToConcreteTypeNames);
                     factory.handleInterfaceObject(node);
@@ -1039,14 +1123,14 @@ class NormalizationFactory {
                     if ((0, utils_1.isNodeExtension)(node)) {
                         return factory.handleObjectLikeExtension(node);
                     }
-                    if (factory.parents.has(name)) {
-                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
+                    if (factory.parentContainerByTypeName.has(typeName)) {
+                        factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), typeName));
                         return false;
                     }
                     const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-                    factory.parents.set(name, {
+                    factory.parentContainerByTypeName.set(typeName, {
                         description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
+                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
                         fields: new Map(),
                         interfaces: (0, utils_1.extractInterfaces)(node, new Set(), factory.errors),
                         isEntity,
@@ -1056,9 +1140,13 @@ class NormalizationFactory {
                     if (!isEntity) {
                         return;
                     }
-                    factory.entities.add(name);
-                    const fieldSets = (0, utils_3.getValueOrDefault)(factory.fieldSetsByParent, name, utils_2.newFieldSetContainer);
-                    factory.extractKeyFieldSets(node, fieldSets.keys);
+                    const fieldSetContainer = (0, utils_3.getValueOrDefault)(factory.fieldSetContainerByTypeName, typeName, utils_2.newFieldSetContainer);
+                    factory.extractKeyFieldSets(node, fieldSetContainer);
+                    (0, utils_3.upsertEntityContainerProperties)(factory.entityContainerByTypeName, {
+                        typeName: factory.parentTypeName,
+                        keyFieldSets: fieldSetContainer.keys,
+                        ...(factory.subgraphName ? { subgraphNames: [factory.subgraphName] } : {}),
+                    });
                 },
                 leave() {
                     factory.isCurrentParentRootType = false;
@@ -1092,16 +1180,16 @@ class NormalizationFactory {
                     if (name === string_constants_1.ANY_SCALAR) {
                         return false;
                     }
-                    const parent = factory.parents.get(name);
+                    const parent = factory.parentContainerByTypeName.get(name);
                     if (parent) {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
                     }
                     factory.parentTypeName = name;
                     factory.lastParentNodeKind = node.kind;
-                    factory.parents.set(name, {
+                    factory.parentContainerByTypeName.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
-                        directives: factory.extractDirectives(node, new Map()),
+                        directives: factory.extractDirectivesAndAuthorization(node, new Map()),
                         kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
                         name: node.name,
                     });
@@ -1117,19 +1205,19 @@ class NormalizationFactory {
                     if (name === string_constants_1.ANY_SCALAR) {
                         return false;
                     }
-                    const extension = factory.extensions.get(name);
+                    const extension = factory.extensionContainerByTypeName.get(name);
                     if (extension) {
                         if (extension.kind !== graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
                             factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
                             return false;
                         }
-                        factory.extractDirectives(node, extension.directives);
+                        factory.extractDirectivesAndAuthorization(node, extension.directives);
                     }
                     else {
                         factory.parentTypeName = name;
                         factory.lastParentNodeKind = node.kind;
-                        factory.extensions.set(name, {
-                            directives: factory.extractDirectives(node, new Map()),
+                        factory.extensionContainerByTypeName.set(name, {
+                            directives: factory.extractDirectivesAndAuthorization(node, new Map()),
                             kind: node.kind,
                             name: node.name,
                         });
@@ -1148,7 +1236,7 @@ class NormalizationFactory {
                         return false;
                     }
                     factory.parentTypeName = name;
-                    const parent = factory.parents.get(name);
+                    const parent = factory.parentContainerByTypeName.get(name);
                     if (parent) {
                         factory.errors.push((0, errors_1.duplicateTypeDefinitionError)((0, utils_3.kindToTypeString)(node.kind), name));
                         return false;
@@ -1159,7 +1247,7 @@ class NormalizationFactory {
                     }
                     factory.lastParentNodeKind = node.kind;
                     (0, utils_1.addConcreteTypesForUnion)(node, factory.abstractToConcreteTypeNames);
-                    factory.parents.set(name, {
+                    factory.parentContainerByTypeName.set(name, {
                         description: (0, utils_1.formatDescription)(node.description),
                         directives: factory.extractDirectives(node, new Map()),
                         kind: node.kind,
@@ -1178,7 +1266,7 @@ class NormalizationFactory {
                     if (name === string_constants_1.ENTITY_UNION) {
                         return false;
                     }
-                    const extension = factory.extensions.get(name);
+                    const extension = factory.extensionContainerByTypeName.get(name);
                     if (!node.types) {
                         factory.errors.push();
                         return false;
@@ -1193,7 +1281,7 @@ class NormalizationFactory {
                         factory.extractDirectives(node, extension.directives);
                     }
                     else {
-                        factory.extensions.set(name, {
+                        factory.extensionContainerByTypeName.set(name, {
                             directives: factory.extractDirectives(node, new Map()),
                             kind: node.kind,
                             name: node.name,
@@ -1211,12 +1299,13 @@ class NormalizationFactory {
         for (const directiveDefinition of constants_1.BASE_DIRECTIVE_DEFINITIONS) {
             definitions.push(directiveDefinition);
         }
-        definitions.push(constants_1.FIELD_SET_DEFINITION);
+        definitions.push(constants_1.FIELD_SET_SCALAR_DEFINITION);
         if (factory.isSubgraphVersionTwo) {
             for (const directiveDefinition of constants_1.VERSION_TWO_DIRECTIVE_DEFINITIONS) {
                 definitions.push(directiveDefinition);
                 this.allDirectiveDefinitions.set(directiveDefinition.name.value, directiveDefinition);
             }
+            definitions.push(constants_1.SCOPE_SCALAR_DEFINITION);
         }
         for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
             definitions.push(directiveDefinition);
@@ -1226,8 +1315,8 @@ class NormalizationFactory {
         }
         const validExtensionOrphans = new Set();
         const parentsToIgnore = new Set();
-        for (const [extensionTypeName, extensionContainer] of this.extensions) {
-            const isEntity = this.entities.has(extensionTypeName);
+        for (const [extensionTypeName, extensionContainer] of this.extensionContainerByTypeName) {
+            const isEntity = this.entityContainerByTypeName.has(extensionTypeName);
             const configurationData = {
                 fieldNames: new Set(),
                 isRootNode: isEntity,
@@ -1241,7 +1330,7 @@ class NormalizationFactory {
                 }
                 (0, utils_2.addNonExternalFieldsToSet)(extensionContainer.fields, configurationData.fieldNames);
             }
-            const baseType = this.parents.get(extensionTypeName);
+            const baseType = this.parentContainerByTypeName.get(extensionTypeName);
             if (!baseType) {
                 if (extensionContainer.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                     this.errors.push((0, errors_1.noBaseTypeExtensionError)(extensionTypeName));
@@ -1306,10 +1395,12 @@ class NormalizationFactory {
                     this.mergeUniqueInterfaces(objectLikeExtension.interfaces, baseType.interfaces, extensionTypeName);
                     this.validateInterfaceImplementations(baseType);
                     definitions.push((0, utils_2.objectLikeContainerToNode)(this, baseType, objectLikeExtension));
-                    // interfaces and objects must define at least one field
+                    // Interfaces and objects must define at least one field
                     if (baseType.fields.size < 1 && !(0, utils_2.isNodeQuery)(extensionTypeName, operationTypeNode)) {
                         this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_3.kindToTypeString)(baseType.kind), extensionTypeName));
                     }
+                    // Add the non-external base type field names to the configuration data
+                    (0, utils_2.addNonExternalFieldsToSet)(baseType.fields, configurationData.fieldNames);
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     definitions.push((0, utils_2.scalarContainerToNode)(this, baseType, extensionContainer));
@@ -1324,7 +1415,7 @@ class NormalizationFactory {
             // At this point, the base type has been dealt with, so it doesn't need to be dealt with again
             parentsToIgnore.add(extensionTypeName);
         }
-        for (const [parentTypeName, parentContainer] of this.parents) {
+        for (const [parentTypeName, parentContainer] of this.parentContainerByTypeName) {
             if (parentsToIgnore.has(parentTypeName)) {
                 continue;
             }
@@ -1338,7 +1429,7 @@ class NormalizationFactory {
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const isEntity = this.entities.has(parentTypeName);
+                    const isEntity = this.entityContainerByTypeName.has(parentTypeName);
                     const operationTypeNode = this.operationTypeNames.get(parentTypeName);
                     if (operationTypeNode) {
                         parentContainer.fields.delete(string_constants_1.SERVICE_FIELD);
@@ -1397,12 +1488,12 @@ class NormalizationFactory {
             const operationTypeName = node ? (0, type_merging_1.getNamedTypeForChild)(`schema.${operationType}`, node.type) : defaultTypeName;
             // If a custom type is used, the default type should not be defined
             if (operationTypeName !== defaultTypeName &&
-                (this.parents.has(defaultTypeName) || this.extensions.has(defaultTypeName))) {
+                (this.parentContainerByTypeName.has(defaultTypeName) || this.extensionContainerByTypeName.has(defaultTypeName))) {
                 this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
                 continue;
             }
-            const object = this.parents.get(operationTypeName);
-            const extension = this.extensions.get(operationTypeName);
+            const object = this.parentContainerByTypeName.get(operationTypeName);
+            const extension = this.extensionContainerByTypeName.get(operationTypeName);
             // Node is truthy if an operation type was explicitly declared
             if (node) {
                 // If the type is not defined in the schema, it's always an error
@@ -1437,7 +1528,7 @@ class NormalizationFactory {
                     const fieldPath = `${operationTypeName}.${fieldName}`;
                     const fieldTypeName = (0, type_merging_1.getNamedTypeForChild)(fieldPath, fieldContainer.node.type);
                     if (!constants_1.BASE_SCALARS.has(fieldTypeName) &&
-                        !this.parents.has(fieldTypeName) &&
+                        !this.parentContainerByTypeName.has(fieldTypeName) &&
                         !validExtensionOrphans.has(fieldTypeName)) {
                         this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
                     }
@@ -1445,16 +1536,17 @@ class NormalizationFactory {
             }
         }
         for (const referencedTypeName of this.referencedTypeNames) {
-            if (this.parents.has(referencedTypeName) || this.entities.has(referencedTypeName)) {
+            if (this.parentContainerByTypeName.has(referencedTypeName) ||
+                this.entityContainerByTypeName.has(referencedTypeName)) {
                 continue;
             }
-            const extension = this.extensions.get(referencedTypeName);
+            const extension = this.extensionContainerByTypeName.get(referencedTypeName);
             if (!extension || extension.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }
-        for (const [parentTypeName, fieldSets] of this.fieldSetsByParent) {
-            const parentContainer = this.parents.get(parentTypeName) || this.extensions.get(parentTypeName);
+        for (const [parentTypeName, fieldSetContainers] of this.fieldSetContainerByTypeName) {
+            const parentContainer = this.parentContainerByTypeName.get(parentTypeName) || this.extensionContainerByTypeName.get(parentTypeName);
             if (!parentContainer ||
                 (parentContainer.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
                     parentContainer.kind != graphql_1.Kind.OBJECT_TYPE_EXTENSION &&
@@ -1464,7 +1556,7 @@ class NormalizationFactory {
                 continue;
             }
             // this is where keys, provides, and requires are added to the ConfigurationData
-            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentContainer, fieldSets);
+            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentContainer, fieldSetContainers);
         }
         if (this.errors.length > 0) {
             return { errors: this.errors };
@@ -1473,16 +1565,21 @@ class NormalizationFactory {
             kind: graphql_1.Kind.DOCUMENT,
             definitions,
         };
+        (0, subgraph_1.walkSubgraphToApplyFieldAuthorization)(factory, newAST);
         return {
             normalizationResult: {
+                authorizationDataByParentTypeName: this.authorizationDataByParentTypeName,
                 // configurationDataMap is map of ConfigurationData per type name.
                 // It is an Intermediate configuration object that will be converted to an engine configuration in the router
                 configurationDataMap: this.configurationDataMap,
+                entityContainerByTypeName: this.entityContainerByTypeName,
                 entityInterfaces: this.entityInterfaces,
+                extensionContainerByTypeName: this.extensionContainerByTypeName,
                 isVersionTwo: this.isSubgraphVersionTwo,
                 keyFieldNamesByParentTypeName: this.keyFieldNamesByParentTypeName,
                 operationTypes: this.operationTypeNames,
                 overridesByTargetSubgraphName: this.overridesByTargetSubgraphName,
+                parentContainerByTypeName: this.parentContainerByTypeName,
                 subgraphAST: newAST,
                 subgraphString: (0, graphql_1.print)(newAST),
                 schema: (0, buildASTSchema_1.buildASTSchema)(newAST, { assumeValid: true }),
@@ -1492,15 +1589,18 @@ class NormalizationFactory {
 }
 exports.NormalizationFactory = NormalizationFactory;
 function batchNormalize(subgraphs) {
-    const internalSubgraphsBySubgraphName = new Map();
+    const authorizationDataByParentTypeName = new Map();
+    const entityContainerByTypeName = new Map();
+    const internalSubgraphBySubgraphName = new Map();
     const allOverridesByTargetSubgraphName = new Map();
     const overrideSourceSubgraphNamesByFieldPath = new Map();
     const duplicateOverriddenFieldPaths = new Set();
-    const validationErrors = [];
+    const parentContainerMapsBySubgraphName = new Map();
     const subgraphNames = new Set();
     const nonUniqueSubgraphNames = new Set();
     const invalidNameErrorMessages = [];
     const warnings = [];
+    const validationErrors = [];
     // Record the subgraph names first, so that subgraph references can be validated
     for (const subgraph of subgraphs) {
         if (subgraph.name) {
@@ -1522,16 +1622,25 @@ function batchNormalize(subgraphs) {
             validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, [errors_1.subgraphValidationFailureError]));
             continue;
         }
+        parentContainerMapsBySubgraphName.set(subgraphName, normalizationResult.parentContainerByTypeName);
+        for (const authorizationData of normalizationResult.authorizationDataByParentTypeName.values()) {
+            (0, utils_3.upsertAuthorizationData)(authorizationDataByParentTypeName, authorizationData);
+        }
+        for (const entityContainer of normalizationResult.entityContainerByTypeName.values()) {
+            (0, utils_3.upsertEntityContainer)(entityContainerByTypeName, entityContainer);
+        }
         if (subgraph.name) {
-            internalSubgraphsBySubgraphName.set(subgraphName, {
+            internalSubgraphBySubgraphName.set(subgraphName, {
                 configurationDataMap: normalizationResult.configurationDataMap,
                 definitions: normalizationResult.subgraphAST,
                 entityInterfaces: normalizationResult.entityInterfaces,
+                extensionContainerByTypeName: normalizationResult.extensionContainerByTypeName,
                 keyFieldNamesByParentTypeName: normalizationResult.keyFieldNamesByParentTypeName,
                 isVersionTwo: normalizationResult.isVersionTwo,
                 name: subgraphName,
                 operationTypes: normalizationResult.operationTypes,
                 overriddenFieldNamesByParentTypeName: new Map(),
+                parentContainerByTypeName: normalizationResult.parentContainerByTypeName,
                 schema: normalizationResult.schema,
                 url: subgraph.url,
             });
@@ -1576,12 +1685,17 @@ function batchNormalize(subgraphs) {
         allErrors.push((0, errors_1.duplicateOverriddenFieldsError)(duplicateOverriddenFieldErrorMessages));
     }
     allErrors.push(...validationErrors);
-    const warningsToPropagate = warnings.length > 0 ? warnings : undefined;
     if (allErrors.length > 0) {
-        return { errors: allErrors, internalSubgraphsBySubgraphName, warnings: warningsToPropagate };
+        return {
+            authorizationDataByParentTypeName,
+            entityContainerByTypeName,
+            errors: allErrors,
+            internalSubgraphBySubgraphName,
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
     }
     for (const [targetSubgraphName, overridesData] of allOverridesByTargetSubgraphName) {
-        const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphsBySubgraphName, targetSubgraphName, 'normalizedSubgraphsByName');
+        const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphBySubgraphName, targetSubgraphName, 'internalSubgraphBySubgraphName');
         internalSubgraph.overriddenFieldNamesByParentTypeName = overridesData;
         for (const [parentTypeName, fieldNames] of overridesData) {
             const configurationData = internalSubgraph.configurationDataMap.get(parentTypeName);
@@ -1595,8 +1709,10 @@ function batchNormalize(subgraphs) {
         }
     }
     return {
-        internalSubgraphsBySubgraphName: internalSubgraphsBySubgraphName,
-        warnings: warningsToPropagate,
+        authorizationDataByParentTypeName,
+        entityContainerByTypeName: entityContainerByTypeName,
+        internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
+        ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
 exports.batchNormalize = batchNormalize;