@wundergraph/composition 0.19.0 → 0.20.1

package/dist/normalization/normalization-factory.js

@@ -25,7 +25,7 @@ function normalizeSubgraphFromString(subgraphSDL) {
     return normalizationFactory.normalize(documentNode);
 }
 exports.normalizeSubgraphFromString = normalizeSubgraphFromString;
-function normalizeSubgraph(document, graph, subgraphName) {
+function normalizeSubgraph(document, subgraphName, graph) {
     const normalizationFactory = new NormalizationFactory(graph || new graphology_1.MultiGraph(), subgraphName);
     return normalizationFactory.normalize(document);
 }
@@ -39,14 +39,15 @@ class NormalizationFactory {
     customDirectiveDefinitions = new Map();
     directiveDefinitionByDirectiveName = new Map();
     errors = [];
-    entityContainerByTypeName = new Map();
+    entityDataByTypeName = new Map();
     entityInterfaces = new Map();
     graph;
     parentExtensionDataByTypeName = new Map();
     interfaceTypeNamesWithAuthorizationDirectives = new Set();
     isCurrentParentExtension = false;
+    isEventDrivenSubgraph = false;
     isSubgraphVersionTwo = false;
-    fieldSetContainerByTypeName = new Map();
+    fieldSetDataByTypeName = new Map();
     heirFieldAuthorizationDataByTypeName = new Map();
     handledRepeatedDirectivesByHostPath = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
@@ -301,16 +302,16 @@ class NormalizationFactory {
         if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION || !isEntity) {
             return;
         }
-        const fieldSetContainer = (0, utils_3.getValueOrDefault)(this.fieldSetContainerByTypeName, this.originalParentTypeName, utils_2.newFieldSetContainer);
-        this.extractKeyFieldSets(node, fieldSetContainer);
-        (0, utils_3.upsertEntityContainerProperties)(this.entityContainerByTypeName, {
+        const fieldSetData = (0, utils_3.getValueOrDefault)(this.fieldSetDataByTypeName, this.originalParentTypeName, utils_2.newFieldSetData);
+        this.extractKeyFieldSets(node, fieldSetData);
+        (0, utils_3.upsertEntityDataProperties)(this.entityDataByTypeName, {
             typeName: this.originalParentTypeName,
-            keyFieldSets: fieldSetContainer.keys,
+            keyFieldSets: fieldSetData.isUnresolvableByKeyFieldSet.keys(),
             ...(this.subgraphName ? { subgraphNames: [this.subgraphName] } : {}),
         });
     }
-    extractKeyFieldSets(node, fieldSetContainer) {
-        const rawFieldSets = fieldSetContainer.keys;
+    extractKeyFieldSets(node, fieldSetData) {
+        const isUnresolvableByRawKeyFieldSet = fieldSetData.isUnresolvableByKeyFieldSet;
         const parentTypeName = node.name.value;
         if (!node.directives?.length) {
             // This should never happen
@@ -326,47 +327,63 @@ class NormalizationFactory {
                 errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(string_constants_1.KEY, parentTypeName, [string_constants_1.FIELDS]));
                 continue;
             }
+            let keyFieldSet;
+            let isUnresolvable = false;
             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;
+                        isUnresolvable = true;
                     }
                     continue;
                 }
                 if (arg.name.value !== string_constants_1.FIELDS) {
-                    errorMessages.push((0, errors_1.unexpectedDirectiveArgumentErrorMessage)(string_constants_1.KEY, argumentName));
+                    keyFieldSet = undefined;
                     break;
                 }
                 if (arg.value.kind !== graphql_1.Kind.STRING) {
+                    keyFieldSet = undefined;
                     errorMessages.push((0, errors_1.invalidKeyDirectiveArgumentErrorMessage)(arg.value.kind));
                     break;
                 }
-                rawFieldSets.add(arg.value.value);
+                keyFieldSet = arg.value.value;
+            }
+            if (keyFieldSet !== undefined) {
+                isUnresolvableByRawKeyFieldSet.set(keyFieldSet, isUnresolvable);
             }
         }
         if (errorMessages.length) {
             this.errors.push((0, errors_1.invalidKeyDirectivesError)(parentTypeName, errorMessages));
         }
     }
-    validateInterfaceImplementations(container) {
-        if (container.implementedInterfaceTypeNames.size < 1) {
+    validateInterfaceImplementations(data) {
+        if (data.implementedInterfaceTypeNames.size < 1) {
             return;
         }
         const implementationErrorsMap = new Map();
-        for (const interfaceName of container.implementedInterfaceTypeNames) {
-            const interfaceContainer = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, 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);
+        const invalidImplementationTypeStringByTypeName = new Map();
+        let doesInterfaceImplementItself = false;
+        for (const interfaceName of data.implementedInterfaceTypeNames) {
+            const implementationData = this.parentDefinitionDataByTypeName.get(interfaceName);
+            if (!implementationData) {
+                this.errors.push((0, errors_1.undefinedTypeError)(interfaceName));
+                continue;
+            }
+            if (implementationData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                invalidImplementationTypeStringByTypeName.set(implementationData.name, (0, utils_3.kindToTypeString)(implementationData.kind));
+                continue;
+            }
+            if (data.name === implementationData.name) {
+                doesInterfaceImplementItself = true;
+                continue;
             }
             const implementationErrors = {
                 invalidFieldImplementations: new Map(),
                 unimplementedFields: [],
             };
             let hasErrors = false;
-            for (const [fieldName, interfaceField] of interfaceContainer.fieldDataByFieldName) {
+            for (const [fieldName, interfaceField] of implementationData.fieldDataByFieldName) {
                 let hasNestedErrors = false;
-                const containerField = container.fieldDataByFieldName.get(fieldName);
+                const containerField = data.fieldDataByFieldName.get(fieldName);
                 if (!containerField) {
                     hasErrors = true;
                     implementationErrors.unimplementedFields.push(fieldName);
@@ -424,8 +441,14 @@ class NormalizationFactory {
                 implementationErrorsMap.set(interfaceName, implementationErrors);
             }
         }
-        if (implementationErrorsMap.size) {
-            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(container.name, (0, utils_3.kindToTypeString)(container.kind), implementationErrorsMap));
+        if (invalidImplementationTypeStringByTypeName.size > 0) {
+            this.errors.push((0, errors_1.invalidImplementedTypeError)(data.name, invalidImplementationTypeStringByTypeName));
+        }
+        if (doesInterfaceImplementItself) {
+            this.errors.push((0, errors_1.selfImplementationError)(data.name));
+        }
+        if (implementationErrorsMap.size > 0) {
+            this.errors.push((0, errors_1.unimplementedInterfaceFieldsError)(data.name, (0, utils_3.kindToTypeString)(data.kind), implementationErrorsMap));
         }
     }
     handleOverrideDeclaration(node, hostPath, errorMessages) {
@@ -444,6 +467,7 @@ class NormalizationFactory {
         overriddenFieldNamesForParent.add(this.childName);
     }
     extractEventDirectivesToConfiguration(node) {
+        // Validation is handled elsewhere
         if (!node.directives) {
             return;
         }
@@ -451,63 +475,248 @@ class NormalizationFactory {
             let eventType;
             switch (directive.name.value) {
                 case string_constants_1.EVENTS_PUBLISH: {
-                    eventType = 'publish';
+                    eventType = string_constants_1.PUBLISH;
                     break;
                 }
                 case string_constants_1.EVENTS_REQUEST: {
-                    eventType = 'request';
+                    eventType = string_constants_1.REQUEST;
                     break;
                 }
                 case string_constants_1.EVENTS_SUBSCRIBE: {
-                    eventType = 'subscribe';
+                    eventType = string_constants_1.SUBSCRIBE;
                     break;
                 }
                 default:
                     continue;
             }
             let topic;
-            let sourceId;
-            for (const arg of directive.arguments || []) {
-                if (arg.value.kind !== graphql_1.Kind.STRING) {
-                    throw new Error(`Event directive arguments must be strings, ${arg.value.kind} found in argument ${arg.name}`);
+            let sourceName;
+            for (const argumentNode of directive.arguments || []) {
+                if (argumentNode.value.kind !== graphql_1.Kind.STRING) {
+                    continue;
                 }
-                switch (arg.name.value) {
+                switch (argumentNode.name.value) {
                     case string_constants_1.TOPIC: {
-                        if (topic !== undefined) {
-                            throw new Error(`Event directives must have exactly one topic argument, found multiple`);
-                        }
-                        if (!arg.value.value) {
-                            throw new Error(`Event directives must have a non-empty topic argument`);
-                        }
-                        topic = arg.value.value;
+                        topic = argumentNode.value.value;
                         break;
                     }
-                    case string_constants_1.SOURCE_ID: {
-                        if (sourceId !== undefined) {
-                            throw new Error(`Event directives must have exactly one sourceID argument, found multiple`);
-                        }
-                        if (!arg.value.value) {
-                            throw new Error(`Event directives must have a non-empty sourceID argument`);
-                        }
-                        sourceId = arg.value.value;
+                    case string_constants_1.SOURCE_NAME: {
+                        sourceName = argumentNode.value.value;
                         break;
                     }
-                    default:
-                        throw new Error(`Unknown argument ${arg.name.value} found in event directive`);
                 }
             }
             if (!topic) {
-                throw new Error(`Event directives must have a topic argument`);
+                return;
             }
             const configuration = (0, utils_3.getValueOrDefault)(this.eventsConfigurations, this.renamedParentTypeName || this.originalParentTypeName, () => []);
             configuration.push({
                 type: eventType,
                 fieldName: this.childName,
                 topic,
-                sourceId,
+                sourceName: sourceName || string_constants_1.DEFAULT,
             });
         }
     }
+    getValidEventsDirectiveNamesForRootTypeName(parentTypeName) {
+        const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
+        if (!operationTypeNode) {
+            switch (parentTypeName) {
+                case string_constants_1.MUTATION:
+                    return new Set([string_constants_1.EVENTS_PUBLISH, string_constants_1.EVENTS_REQUEST]);
+                case string_constants_1.QUERY:
+                    return new Set([string_constants_1.EVENTS_REQUEST]);
+                case string_constants_1.SUBSCRIPTION:
+                    return new Set([string_constants_1.EVENTS_SUBSCRIBE]);
+                default:
+                    return;
+            }
+        }
+        switch (operationTypeNode) {
+            case graphql_1.OperationTypeNode.MUTATION:
+                return new Set([string_constants_1.EVENTS_REQUEST, string_constants_1.EVENTS_PUBLISH]);
+            case graphql_1.OperationTypeNode.QUERY:
+                return new Set([string_constants_1.EVENTS_REQUEST]);
+            case graphql_1.OperationTypeNode.SUBSCRIPTION:
+                return new Set([string_constants_1.EVENTS_SUBSCRIBE]);
+            default:
+                return;
+        }
+    }
+    validateEventDrivenRootType(data, validEventsDirectiveNames, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath) {
+        const isMutation = validEventsDirectiveNames.has(string_constants_1.EVENTS_PUBLISH);
+        for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
+            const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
+            const definedEventsDirectiveNames = new Set();
+            for (const eventsDirectiveName of string_constants_1.EVENT_DIRECTIVE_NAMES) {
+                if (fieldData.directivesByDirectiveName.has(eventsDirectiveName)) {
+                    definedEventsDirectiveNames.add(eventsDirectiveName);
+                }
+            }
+            const invalidEventsDirectiveNames = new Set();
+            for (const definedEventsDirectiveName of definedEventsDirectiveNames) {
+                if (!validEventsDirectiveNames.has(definedEventsDirectiveName)) {
+                    invalidEventsDirectiveNames.add(definedEventsDirectiveName);
+                }
+            }
+            if (definedEventsDirectiveNames.size < 1 || invalidEventsDirectiveNames.size > 0) {
+                invalidEventsDirectiveDataByRootFieldPath.set(fieldPath, {
+                    definesDirectives: definedEventsDirectiveNames.size > 0,
+                    invalidDirectiveNames: [...invalidEventsDirectiveNames],
+                });
+            }
+            if (isMutation) {
+                const typeString = (0, merge_1.printTypeNode)(fieldData.type);
+                if (typeString !== string_constants_1.NON_NULLABLE_PUBLISH_EVENT_RESULT) {
+                    invalidResponseTypeNameByMutationPath.set(fieldPath, typeString);
+                }
+                continue;
+            }
+            const fieldTypeString = (0, merge_1.printTypeNode)(fieldData.type);
+            const expectedTypeString = fieldData.namedTypeName + '!';
+            let isValid = false;
+            const concreteTypeNames = this.concreteTypeNamesByAbstractTypeName.get(fieldData.namedTypeName) ||
+                new Set([fieldData.namedTypeName]);
+            for (const concreteTypeName of concreteTypeNames) {
+                isValid ||= this.entityDataByTypeName.has(concreteTypeName);
+                if (isValid) {
+                    break;
+                }
+            }
+            if (!isValid || fieldTypeString !== expectedTypeString) {
+                invalidResponseTypeStringByRootFieldPath.set(fieldPath, fieldTypeString);
+            }
+        }
+    }
+    validateEventDrivenKeyDefinition(typeName, invalidKeyFieldSetsByEntityTypeName) {
+        const fieldSetData = this.fieldSetDataByTypeName.get(typeName);
+        if (!fieldSetData) {
+            return;
+        }
+        for (const [keyFieldSet, isUnresolvable] of fieldSetData.isUnresolvableByKeyFieldSet) {
+            if (isUnresolvable) {
+                continue;
+            }
+            (0, utils_3.getValueOrDefault)(invalidKeyFieldSetsByEntityTypeName, typeName, () => []).push(keyFieldSet);
+        }
+    }
+    validateEventDrivenObjectFields(fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath) {
+        for (const [fieldName, fieldData] of fieldDataByFieldName) {
+            const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
+            if (keyFieldNames.has(fieldName)) {
+                if (!fieldData.isExternalBySubgraphName.get(this.subgraphName)) {
+                    nonExternalKeyFieldNameByFieldPath.set(fieldPath, fieldName);
+                }
+                continue;
+            }
+            nonKeyFieldNameByFieldPath.set(fieldPath, fieldName);
+        }
+    }
+    isPublishEventResultValid() {
+        const data = this.parentDefinitionDataByTypeName.get(string_constants_1.PUBLISH_EVENT_RESULT);
+        if (!data) {
+            return true;
+        }
+        if (data.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+            return false;
+        }
+        if (data.fieldDataByFieldName.size != 1) {
+            return false;
+        }
+        for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
+            if (fieldData.argumentDataByArgumentName.size > 0) {
+                return false;
+            }
+            if (fieldName !== string_constants_1.SUCCESS) {
+                return false;
+            }
+            if ((0, merge_1.printTypeNode)(fieldData.type) !== string_constants_1.NON_NULLABLE_BOOLEAN) {
+                return false;
+            }
+        }
+        return true;
+    }
+    validateEventDrivenSubgraph() {
+        const errorMessages = [];
+        const invalidEventsDirectiveDataByRootFieldPath = new Map();
+        const invalidResponseTypeStringByRootFieldPath = new Map();
+        const invalidResponseTypeNameByMutationPath = new Map();
+        const invalidKeyFieldSetsByEntityTypeName = new Map();
+        const nonExternalKeyFieldNameByFieldPath = new Map();
+        const nonKeyFieldNameByFieldPath = new Map();
+        const nonEntityExtensionTypeNames = new Set();
+        const invalidObjectTypeNames = new Set();
+        for (const [typeName, data] of this.parentExtensionDataByTypeName) {
+            if (data.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                continue;
+            }
+            // If a required events directive is returned, the parent type is a root type
+            const validEventsDirectiveNames = this.getValidEventsDirectiveNamesForRootTypeName(data.name);
+            if (validEventsDirectiveNames) {
+                this.validateEventDrivenRootType(data, validEventsDirectiveNames, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath);
+                continue;
+            }
+            const keyFieldNames = this.keyFieldNamesByParentTypeName.get(typeName);
+            if (!keyFieldNames || !data.isEntity) {
+                nonEntityExtensionTypeNames.add(typeName);
+                continue;
+            }
+            this.validateEventDrivenKeyDefinition(typeName, invalidKeyFieldSetsByEntityTypeName);
+            this.validateEventDrivenObjectFields(data.fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath);
+        }
+        for (const [typeName, data] of this.parentDefinitionDataByTypeName) {
+            if (data.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                continue;
+            }
+            // validate PublishEventResult separately
+            if (typeName === string_constants_1.PUBLISH_EVENT_RESULT) {
+                continue;
+            }
+            // If a required events directive is returned, the parent type is a root type
+            const validEventsDirectiveNames = this.getValidEventsDirectiveNamesForRootTypeName(data.name);
+            if (validEventsDirectiveNames) {
+                this.validateEventDrivenRootType(data, validEventsDirectiveNames, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath);
+                continue;
+            }
+            const keyFieldNames = this.keyFieldNamesByParentTypeName.get(typeName);
+            if (!keyFieldNames) {
+                invalidObjectTypeNames.add(typeName);
+                continue;
+            }
+            this.validateEventDrivenKeyDefinition(typeName, invalidKeyFieldSetsByEntityTypeName);
+            this.validateEventDrivenObjectFields(data.fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath);
+        }
+        if (!this.isPublishEventResultValid()) {
+            errorMessages.push(errors_1.invalidPublishEventResultObjectErrorMessage);
+        }
+        if (invalidEventsDirectiveDataByRootFieldPath.size > 0) {
+            errorMessages.push((0, errors_1.invalidRootTypeFieldEventsDirectivesErrorMessage)(invalidEventsDirectiveDataByRootFieldPath));
+        }
+        if (invalidResponseTypeNameByMutationPath.size > 0) {
+            errorMessages.push((0, errors_1.invalidEventsDrivenMutationResponseTypeErrorMessage)(invalidResponseTypeNameByMutationPath));
+        }
+        if (invalidResponseTypeStringByRootFieldPath.size > 0) {
+            errorMessages.push((0, errors_1.invalidRootTypeFieldResponseTypesEventDrivenErrorMessage)(invalidResponseTypeStringByRootFieldPath));
+        }
+        if (invalidKeyFieldSetsByEntityTypeName.size > 0) {
+            errorMessages.push((0, errors_1.invalidKeyFieldSetsEventDrivenErrorMessage)(invalidKeyFieldSetsByEntityTypeName));
+        }
+        if (nonExternalKeyFieldNameByFieldPath.size > 0) {
+            errorMessages.push((0, errors_1.nonExternalKeyFieldNamesEventDrivenErrorMessage)(nonExternalKeyFieldNameByFieldPath));
+        }
+        if (nonKeyFieldNameByFieldPath.size > 0) {
+            errorMessages.push((0, errors_1.nonKeyFieldNamesEventDrivenErrorMessage)(nonKeyFieldNameByFieldPath));
+        }
+        if (nonEntityExtensionTypeNames.size > 0) {
+            errorMessages.push((0, errors_1.nonEntityObjectExtensionsEventDrivenErrorMessage)([...nonEntityExtensionTypeNames]));
+        }
+        if (invalidObjectTypeNames.size > 0) {
+            errorMessages.push((0, errors_1.nonKeyComposingObjectTypeNamesEventDrivenErrorMessage)([...invalidObjectTypeNames]));
+        }
+        if (errorMessages.length > 0) {
+            this.errors.push((0, errors_1.invalidEventDrivenGraphError)(errorMessages));
+        }
+    }
     normalize(document) {
         /* factory.allDirectiveDefinitions is initialized with v1 directive definitions, and v2 definitions are only added
         after the visitor has visited the entire schema and the subgraph is known to be a V2 graph. Consequently,
@@ -567,7 +776,7 @@ class NormalizationFactory {
         const validParentExtensionOrphansByTypeName = new Map();
         const handledParentTypeNames = new Set();
         for (const [extensionTypeName, parentExtensionData] of this.parentExtensionDataByTypeName) {
-            const isEntity = this.entityContainerByTypeName.has(extensionTypeName);
+            const isEntity = this.entityDataByTypeName.has(extensionTypeName);
             const newParentTypeName = parentExtensionData.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION
                 ? parentExtensionData.renamedTypeName || extensionTypeName
                 : extensionTypeName;
@@ -685,7 +894,7 @@ class NormalizationFactory {
                 case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
                 // intentional fallthrough
                 case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-                    const isEntity = this.entityContainerByTypeName.has(parentTypeName);
+                    const isEntity = this.entityDataByTypeName.has(parentTypeName);
                     const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
                     if (operationTypeNode) {
                         parentDefinitionData.fieldDataByFieldName.delete(string_constants_1.SERVICE_FIELD);
@@ -795,7 +1004,7 @@ class NormalizationFactory {
         }
         for (const referencedTypeName of this.referencedTypeNames) {
             if (this.parentDefinitionDataByTypeName.has(referencedTypeName) ||
-                this.entityContainerByTypeName.has(referencedTypeName)) {
+                this.entityDataByTypeName.has(referencedTypeName)) {
                 continue;
             }
             const extension = this.parentExtensionDataByTypeName.get(referencedTypeName);
@@ -803,7 +1012,7 @@ class NormalizationFactory {
                 this.errors.push((0, errors_1.undefinedTypeError)(referencedTypeName));
             }
         }
-        for (const [parentTypeName, fieldSetContainers] of this.fieldSetContainerByTypeName) {
+        for (const [parentTypeName, fieldSetData] of this.fieldSetDataByTypeName) {
             const parentData = this.parentDefinitionDataByTypeName.get(parentTypeName) ||
                 this.parentExtensionDataByTypeName.get(parentTypeName);
             if (!parentData ||
@@ -815,7 +1024,7 @@ class NormalizationFactory {
                 continue;
             }
             // this is where keys, provides, and requires are added to the ConfigurationData
-            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentData, fieldSetContainers);
+            (0, utils_2.validateAndAddDirectivesWithFieldSetToConfigurationData)(this, parentData, fieldSetData);
         }
         const persistedDirectiveDefinitionDataByDirectiveName = new Map();
         for (const directiveDefinitionNode of this.directiveDefinitionByDirectiveName.values()) {
@@ -826,6 +1035,9 @@ class NormalizationFactory {
             }
             (0, utils_4.addPersistedDirectiveDefinitionDataByNode)(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, executableLocations, this.subgraphName);
         }
+        if (this.isEventDrivenSubgraph) {
+            this.validateEventDrivenSubgraph();
+        }
         if (this.errors.length > 0) {
             return { errors: this.errors };
         }
@@ -840,7 +1052,7 @@ class NormalizationFactory {
                 // It is an Intermediate configuration object that will be converted to an engine configuration in the router
                 concreteTypeNamesByAbstractTypeName: this.concreteTypeNamesByAbstractTypeName,
                 configurationDataByParentTypeName: this.configurationDataByParentTypeName,
-                entityContainerByTypeName: this.entityContainerByTypeName,
+                entityContainerByTypeName: this.entityDataByTypeName,
                 entityInterfaces: this.entityInterfaces,
                 parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
                 parentExtensionDataByTypeName: validParentExtensionOrphansByTypeName,
@@ -862,7 +1074,7 @@ exports.NormalizationFactory = NormalizationFactory;
 function batchNormalize(subgraphs) {
     const authorizationDataByParentTypeName = new Map();
     const concreteTypeNamesByAbstractTypeName = new Map();
-    const entityContainerByTypeName = new Map();
+    const entityDataByTypeName = new Map();
     const internalSubgraphBySubgraphName = new Map();
     const allOverridesByTargetSubgraphName = new Map();
     const overrideSourceSubgraphNamesByFieldPath = new Map();
@@ -887,7 +1099,7 @@ function batchNormalize(subgraphs) {
         if (!subgraph.name) {
             invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
         }
-        const { errors, normalizationResult } = normalizeSubgraph(subgraph.definitions, graph, subgraph.name);
+        const { errors, normalizationResult } = normalizeSubgraph(subgraph.definitions, subgraph.name, graph);
         if (errors) {
             validationErrors.push((0, errors_1.subgraphValidationError)(subgraphName, errors));
             continue;
@@ -909,7 +1121,7 @@ function batchNormalize(subgraphs) {
             (0, utils_3.addIterableValuesToSet)(incomingConcreteTypeNames, existingConcreteTypeNames);
         }
         for (const entityContainer of normalizationResult.entityContainerByTypeName.values()) {
-            (0, utils_3.upsertEntityContainer)(entityContainerByTypeName, entityContainer);
+            (0, utils_3.upsertEntityData)(entityDataByTypeName, entityContainer);
         }
         if (subgraph.name) {
             internalSubgraphBySubgraphName.set(subgraphName, {
@@ -978,7 +1190,7 @@ function batchNormalize(subgraphs) {
         return {
             authorizationDataByParentTypeName,
             concreteTypeNamesByAbstractTypeName,
-            entityContainerByTypeName,
+            entityContainerByTypeName: entityDataByTypeName,
             errors: allErrors,
             graph,
             internalSubgraphBySubgraphName,
@@ -1002,7 +1214,7 @@ function batchNormalize(subgraphs) {
     return {
         authorizationDataByParentTypeName,
         concreteTypeNamesByAbstractTypeName,
-        entityContainerByTypeName: entityContainerByTypeName,
+        entityContainerByTypeName: entityDataByTypeName,
         graph,
         internalSubgraphBySubgraphName: internalSubgraphBySubgraphName,
         ...(warnings.length > 0 ? { warnings } : {}),