@wundergraph/composition 0.14.0 → 0.16.0

package/dist/normalization/normalization-factory.js

@@ -36,28 +36,28 @@ class NormalizationFactory {
     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;
-    keyFieldsByParentTypeName = new Map();
+    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 +74,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: '' };
@@ -282,7 +282,7 @@ 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) {
@@ -294,7 +294,7 @@ class NormalizationFactory {
             return;
         }
         const isEntity = (0, utils_1.isObjectLikeNodeEntity)(node);
-        this.extensions.set(this.parentTypeName, {
+        this.extensionContainerByTypeName.set(this.parentTypeName, {
             directives: this.extractDirectives(node, new Map()),
             fields: new Map(),
             interfaces: (0, utils_1.extractInterfaces)(node, new Set(), this.errors),
@@ -305,9 +305,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 +399,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 +419,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 +445,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 +518,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 +660,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 +725,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;
@@ -732,13 +739,13 @@ class NormalizationFactory {
             EnumTypeDefinition: {
                 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.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()),
                         kind: node.kind,
@@ -757,7 +764,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.ENUM_TYPE_EXTENSION) {
                             factory.errors.push((0, errors_1.incompatibleExtensionKindsError)(node, extension.kind));
@@ -766,7 +773,7 @@ class NormalizationFactory {
                         factory.extractDirectives(node, extension.directives);
                         return;
                     }
-                    factory.extensions.set(name, {
+                    factory.extensionContainerByTypeName.set(name, {
                         directives: factory.extractDirectives(node, new Map()),
                         kind: node.kind,
                         name: node.name,
@@ -785,8 +792,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 +817,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,
+                        name: fieldName,
                         node: {
                             ...node,
                             arguments: node.arguments?.map((arg) => ({
@@ -851,27 +858,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 +892,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 +917,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 +926,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 +955,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,20 +987,12 @@ 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, {
-                            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()),
                         fields: new Map(),
@@ -1001,9 +1004,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 = '';
@@ -1025,12 +1038,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);
@@ -1038,12 +1051,12 @@ 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()),
                         fields: new Map(),
@@ -1055,9 +1068,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;
@@ -1091,14 +1108,14 @@ 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()),
                         kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION,
@@ -1116,7 +1133,7 @@ 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));
@@ -1127,7 +1144,7 @@ class NormalizationFactory {
                     else {
                         factory.parentTypeName = name;
                         factory.lastParentNodeKind = node.kind;
-                        factory.extensions.set(name, {
+                        factory.extensionContainerByTypeName.set(name, {
                             directives: factory.extractDirectives(node, new Map()),
                             kind: node.kind,
                             name: node.name,
@@ -1147,7 +1164,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;
@@ -1158,7 +1175,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,
@@ -1177,7 +1194,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;
@@ -1192,7 +1209,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,
@@ -1225,8 +1242,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,
@@ -1240,7 +1257,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));
@@ -1305,10 +1322,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));
@@ -1323,7 +1342,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;
             }
@@ -1337,7 +1356,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);
@@ -1358,6 +1377,13 @@ class NormalizationFactory {
                         isRootNode: isEntity,
                         typeName: parentTypeName,
                     };
+                    const entityInterfaceData = this.entityInterfaces.get(parentTypeName);
+                    if (entityInterfaceData) {
+                        entityInterfaceData.concreteTypeNames =
+                            this.abstractToConcreteTypeNames.get(parentTypeName) || new Set();
+                        configurationData.isInterfaceObject = entityInterfaceData.isInterfaceObject;
+                        configurationData.entityInterfaceConcreteTypeNames = entityInterfaceData.concreteTypeNames;
+                    }
                     const events = this.eventsConfigurations.get(parentTypeName);
                     if (events) {
                         configurationData.events = events;
@@ -1389,12 +1415,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
@@ -1429,7 +1455,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));
                     }
@@ -1437,16 +1463,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 &&
@@ -1455,7 +1482,8 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.undefinedObjectLikeParentError)(parentTypeName));
                 continue;
             }
-            (0, utils_2.validateDirectivesWithFieldSet)(this, parentContainer, fieldSets);
+            // this is where keys, provides, and requires are added to the ConfigurationData
+            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentContainer, fieldSetContainers);
         }
         if (this.errors.length > 0) {
             return { errors: this.errors };
@@ -1469,11 +1497,14 @@ class NormalizationFactory {
                 // 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,
-                keyFieldsByParentTypeName: this.keyFieldsByParentTypeName,
+                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 }),
@@ -1483,15 +1514,17 @@ class NormalizationFactory {
 }
 exports.NormalizationFactory = NormalizationFactory;
 function batchNormalize(subgraphs) {
+    const entityContainersByTypeName = new Map();
     const internalSubgraphsBySubgraphName = 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) {
@@ -1513,16 +1546,22 @@ function batchNormalize(subgraphs) {
             validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, [errors_1.subgraphValidationFailureError]));
             continue;
         }
+        parentContainerMapsBySubgraphName.set(subgraphName, normalizationResult.parentContainerByTypeName);
+        for (const entityContainer of normalizationResult.entityContainerByTypeName.values()) {
+            (0, utils_3.upsertEntityContainer)(entityContainersByTypeName, entityContainer);
+        }
         if (subgraph.name) {
             internalSubgraphsBySubgraphName.set(subgraphName, {
                 configurationDataMap: normalizationResult.configurationDataMap,
                 definitions: normalizationResult.subgraphAST,
                 entityInterfaces: normalizationResult.entityInterfaces,
-                keyFieldsByParentTypeName: normalizationResult.keyFieldsByParentTypeName,
+                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,
             });
@@ -1567,9 +1606,13 @@ 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 {
+            entityContainerByTypeName: entityContainersByTypeName,
+            errors: allErrors,
+            internalSubgraphBySubgraphName: internalSubgraphsBySubgraphName,
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
     }
     for (const [targetSubgraphName, overridesData] of allOverridesByTargetSubgraphName) {
         const internalSubgraph = (0, utils_3.getOrThrowError)(internalSubgraphsBySubgraphName, targetSubgraphName, 'normalizedSubgraphsByName');
@@ -1586,8 +1629,9 @@ function batchNormalize(subgraphs) {
         }
     }
     return {
-        internalSubgraphsBySubgraphName: internalSubgraphsBySubgraphName,
-        warnings: warningsToPropagate,
+        entityContainerByTypeName: entityContainersByTypeName,
+        internalSubgraphBySubgraphName: internalSubgraphsBySubgraphName,
+        ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
 exports.batchNormalize = batchNormalize;