@wundergraph/composition 0.23.2 → 0.25.0

package/dist/normalization/normalization-factory.js

@@ -38,14 +38,15 @@ class NormalizationFactory {
     configurationDataByParentTypeName = new Map();
     customDirectiveDefinitions = new Map();
     directiveDefinitionByDirectiveName = new Map();
+    edfsDirectiveReferences = new Set();
     errors = [];
     entityDataByTypeName = new Map();
     entityInterfaces = new Map();
+    eventsConfigurations = new Map();
     graph;
     parentExtensionDataByTypeName = new Map();
     interfaceTypeNamesWithAuthorizationDirectives = new Set();
     isCurrentParentExtension = false;
-    isEventDrivenSubgraph = false;
     isSubgraphVersionTwo = false;
     fieldSetDataByTypeName = new Map();
     heirFieldAuthorizationDataByTypeName = new Map();
@@ -59,15 +60,14 @@ class NormalizationFactory {
     parentDefinitionDataByTypeName = new Map();
     originalParentTypeName = '';
     parentsWithChildArguments = new Set();
-    eventsConfigurations = new Map();
     overridesByTargetSubgraphName = new Map();
     invalidOrScopesHostPaths = new Set();
     schemaDefinition;
     referencedDirectiveNames = new Set();
     referencedTypeNames = new Set();
     renamedParentTypeName = '';
-    warnings = [];
     subgraphName;
+    warnings = [];
     constructor(graph, subgraphName) {
         for (const [baseDirectiveName, baseDirectiveDefinition] of constants_1.BASE_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME) {
             this.directiveDefinitionByDirectiveName.set(baseDirectiveName, baseDirectiveDefinition);
@@ -474,25 +474,93 @@ class NormalizationFactory {
         const overriddenFieldNamesForParent = (0, utils_3.getValueOrDefault)(overrideDataForSubgraph, this.renamedParentTypeName || this.originalParentTypeName, () => new Set());
         overriddenFieldNamesForParent.add(this.childName);
     }
-    getEventPublishAndRequestConfiguration(eventType, directive, errorMessages) {
+    getKafkaPublishConfiguration(directive, errorMessages) {
+        const topics = [];
+        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        for (const argumentNode of directive.arguments || []) {
+            switch (argumentNode.name.value) {
+                case string_constants_1.TOPIC: {
+                    if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
+                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_1.TOPIC));
+                        continue;
+                    }
+                    topics.push(argumentNode.value.value);
+                    break;
+                }
+                case string_constants_1.PROVIDER_ID: {
+                    if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
+                        errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
+                        continue;
+                    }
+                    providerId = argumentNode.value.value;
+                    break;
+                }
+            }
+        }
+        if (errorMessages.length > 0) {
+            return;
+        }
+        return { fieldName: this.childName, providerId, providerType: string_constants_1.PROVIDER_TYPE_KAFKA, topics, type: string_constants_1.PUBLISH };
+    }
+    getKafkaSubscribeConfiguration(directive, errorMessages) {
+        const topics = [];
+        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
+        for (const argumentNode of directive.arguments || []) {
+            switch (argumentNode.name.value) {
+                case string_constants_1.TOPICS: {
+                    if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
+                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_1.TOPICS));
+                        continue;
+                    }
+                    for (const value of argumentNode.value.values) {
+                        if (value.kind !== graphql_1.Kind.STRING || value.value.length < 1) {
+                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_1.TOPICS));
+                            break;
+                        }
+                        topics.push(value.value);
+                    }
+                    break;
+                }
+                case string_constants_1.PROVIDER_ID: {
+                    if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
+                        errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
+                        continue;
+                    }
+                    providerId = argumentNode.value.value;
+                    break;
+                }
+            }
+        }
+        if (errorMessages.length > 0) {
+            return;
+        }
+        return {
+            fieldName: this.childName,
+            providerId,
+            providerType: string_constants_1.PROVIDER_TYPE_KAFKA,
+            topics: topics,
+            type: string_constants_1.SUBSCRIBE,
+        };
+    }
+    getNatsPublishAndRequestConfiguration(eventType, directive, errorMessages) {
         const subjects = [];
-        let sourceName = string_constants_1.DEFAULT;
+        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
                 case string_constants_1.SUBJECT: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
-                        errorMessages.push(errors_1.invalidEventSubjectErrorMessage);
+                        errorMessages.push((0, errors_1.invalidEventSubjectErrorMessage)(string_constants_1.SUBJECT));
                         continue;
                     }
                     subjects.push(argumentNode.value.value);
                     break;
                 }
-                case string_constants_1.SOURCE_NAME: {
+                case string_constants_1.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
-                        errorMessages.push(errors_1.invalidEventSourceNameErrorMessage);
+                        errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
                     }
-                    sourceName = argumentNode.value.value;
+                    providerId = argumentNode.value.value;
                     break;
                 }
             }
@@ -500,40 +568,40 @@ class NormalizationFactory {
         if (errorMessages.length > 0) {
             return;
         }
-        return { fieldName: this.childName, sourceName, subjects, type: eventType };
+        return { fieldName: this.childName, providerId, providerType: string_constants_1.PROVIDER_TYPE_NATS, subjects, type: eventType };
     }
-    getEventSubscribeConfiguration(directive, errorMessages) {
+    getNatsSubscribeConfiguration(directive, errorMessages) {
         const subjects = [];
-        let sourceName = string_constants_1.DEFAULT;
+        let providerId = string_constants_1.DEFAULT_EDFS_PROVIDER_ID;
         let consumerName = '';
         let streamName = '';
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
                 case string_constants_1.SUBJECTS: {
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
-                        errorMessages.push(errors_1.invalidEventSubjectsErrorMessage);
+                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_1.SUBJECTS));
                         continue;
                     }
                     for (const value of argumentNode.value.values) {
                         if (value.kind !== graphql_1.Kind.STRING || value.value.length < 1) {
-                            errorMessages.push(errors_1.invalidEventSubjectsItemErrorMessage);
+                            errorMessages.push((0, errors_1.invalidEventSubjectsItemErrorMessage)(string_constants_1.SUBJECTS));
                             break;
                         }
                         subjects.push(value.value);
                     }
                     break;
                 }
-                case string_constants_1.SOURCE_NAME: {
+                case string_constants_1.PROVIDER_ID: {
                     if (argumentNode.value.kind !== graphql_1.Kind.STRING || argumentNode.value.value.length < 1) {
-                        errorMessages.push(errors_1.invalidEventSourceNameErrorMessage);
+                        errorMessages.push(errors_1.invalidEventProviderIdErrorMessage);
                         continue;
                     }
-                    sourceName = argumentNode.value.value;
+                    providerId = argumentNode.value.value;
                     break;
                 }
                 case string_constants_1.STREAM_CONFIGURATION: {
                     if (argumentNode.value.kind !== graphql_1.Kind.OBJECT || argumentNode.value.fields.length < 1) {
-                        errorMessages.push(errors_1.invalidEventDrivenStreamConfigurationInputErrorMessage);
+                        errorMessages.push(errors_1.invalidNatsStreamInputErrorMessage);
                         continue;
                     }
                     let isValid = true;
@@ -571,7 +639,7 @@ class NormalizationFactory {
                         }
                     }
                     if (!isValid || missingRequiredFieldNames.size > 0) {
-                        errorMessages.push((0, errors_1.invalidEventDrivenStreamConfigurationInputFieldsErrorMessage)([...missingRequiredFieldNames], [...duplicateRequiredFieldNames], [...invalidRequiredFieldNames], [...invalidFieldNames]));
+                        errorMessages.push((0, errors_1.invalidNatsStreamInputFieldsErrorMessage)([...missingRequiredFieldNames], [...duplicateRequiredFieldNames], [...invalidRequiredFieldNames], [...invalidFieldNames]));
                     }
                 }
             }
@@ -581,12 +649,30 @@ class NormalizationFactory {
         }
         return {
             fieldName: this.childName,
-            sourceName,
+            providerId,
+            providerType: string_constants_1.PROVIDER_TYPE_NATS,
             subjects,
             type: string_constants_1.SUBSCRIBE,
             ...(consumerName && streamName ? { streamConfiguration: { consumerName: consumerName, streamName } } : {}),
         };
     }
+    validateSubscriptionFilterDirectiveLocation(node) {
+        if (!node.directives) {
+            return;
+        }
+        const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
+        const fieldPath = `${parentTypeName}.${node.name.value}`;
+        const isSubscription = this.getOperationTypeNodeForRootTypeName(parentTypeName) === graphql_1.OperationTypeNode.SUBSCRIPTION;
+        for (const directiveNode of node.directives) {
+            if (directiveNode.name.value !== string_constants_1.SUBSCRIPTION_FILTER) {
+                continue;
+            }
+            if (!isSubscription) {
+                this.errors.push((0, errors_1.invalidSubscriptionFilterLocationError)(fieldPath));
+                return;
+            }
+        }
+    }
     extractEventDirectivesToConfiguration(node) {
         // Validation is handled elsewhere
         if (!node.directives) {
@@ -597,16 +683,22 @@ class NormalizationFactory {
             const errorMessages = [];
             let eventConfiguration;
             switch (directive.name.value) {
-                case string_constants_1.EDFS_PUBLISH: {
-                    eventConfiguration = this.getEventPublishAndRequestConfiguration(string_constants_1.PUBLISH, directive, errorMessages);
+                case string_constants_1.EDFS_KAFKA_PUBLISH:
+                    eventConfiguration = this.getKafkaPublishConfiguration(directive, errorMessages);
+                    break;
+                case string_constants_1.EDFS_KAFKA_SUBSCRIBE:
+                    eventConfiguration = this.getKafkaSubscribeConfiguration(directive, errorMessages);
+                    break;
+                case string_constants_1.EDFS_NATS_PUBLISH: {
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_1.PUBLISH, directive, errorMessages);
                     break;
                 }
-                case string_constants_1.EDFS_REQUEST: {
-                    eventConfiguration = this.getEventPublishAndRequestConfiguration(string_constants_1.REQUEST, directive, errorMessages);
+                case string_constants_1.EDFS_NATS_REQUEST: {
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_1.REQUEST, directive, errorMessages);
                     break;
                 }
-                case string_constants_1.EDFS_SUBSCRIBE: {
-                    eventConfiguration = this.getEventSubscribeConfiguration(directive, errorMessages);
+                case string_constants_1.EDFS_NATS_SUBSCRIBE: {
+                    eventConfiguration = this.getNatsSubscribeConfiguration(directive, errorMessages);
                     break;
                 }
                 default:
@@ -623,33 +715,40 @@ class NormalizationFactory {
             (0, utils_3.getValueOrDefault)(this.eventsConfigurations, this.renamedParentTypeName || this.originalParentTypeName, () => []).push(eventConfiguration);
         }
     }
-    getValidEventsDirectiveNamesForRootTypeName(parentTypeName) {
-        const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
-        if (!operationTypeNode) {
-            switch (parentTypeName) {
-                case string_constants_1.MUTATION:
-                    return new Set([string_constants_1.EDFS_PUBLISH, string_constants_1.EDFS_REQUEST]);
-                case string_constants_1.QUERY:
-                    return new Set([string_constants_1.EDFS_REQUEST]);
-                case string_constants_1.SUBSCRIPTION:
-                    return new Set([string_constants_1.EDFS_SUBSCRIBE]);
-                default:
-                    return;
-            }
-        }
+    getValidEventsDirectiveNamesForOperationTypeNode(operationTypeNode) {
         switch (operationTypeNode) {
             case graphql_1.OperationTypeNode.MUTATION:
-                return new Set([string_constants_1.EDFS_REQUEST, string_constants_1.EDFS_PUBLISH]);
+                return new Set([string_constants_1.EDFS_KAFKA_PUBLISH, string_constants_1.EDFS_NATS_PUBLISH, string_constants_1.EDFS_NATS_REQUEST]);
             case graphql_1.OperationTypeNode.QUERY:
-                return new Set([string_constants_1.EDFS_REQUEST]);
+                return new Set([string_constants_1.EDFS_NATS_REQUEST]);
             case graphql_1.OperationTypeNode.SUBSCRIPTION:
-                return new Set([string_constants_1.EDFS_SUBSCRIBE]);
+                return new Set([string_constants_1.EDFS_KAFKA_SUBSCRIBE, string_constants_1.EDFS_NATS_SUBSCRIBE]);
+        }
+    }
+    getOperationTypeNodeForRootTypeName(parentTypeName) {
+        const operationTypeNode = this.operationTypeNodeByTypeName.get(parentTypeName);
+        if (operationTypeNode) {
+            return operationTypeNode;
+        }
+        switch (parentTypeName) {
+            case string_constants_1.MUTATION:
+                return graphql_1.OperationTypeNode.MUTATION;
+            case string_constants_1.QUERY:
+                return graphql_1.OperationTypeNode.QUERY;
+            case string_constants_1.SUBSCRIPTION:
+                return graphql_1.OperationTypeNode.SUBSCRIPTION;
             default:
                 return;
         }
     }
-    validateEventDrivenRootType(data, validEventsDirectiveNames, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath) {
-        const isMutation = validEventsDirectiveNames.has(string_constants_1.EDFS_PUBLISH);
+    validateEventDrivenRootType(data, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath) {
+        const operationTypeNode = this.getOperationTypeNodeForRootTypeName(data.name);
+        if (!operationTypeNode) {
+            // should never happen
+            this.errors.push((0, errors_1.invalidRootTypeError)(data.name));
+            return;
+        }
+        const validEventDirectiveNames = this.getValidEventsDirectiveNamesForOperationTypeNode(operationTypeNode);
         for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
             const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
             const definedEventsDirectiveNames = new Set();
@@ -660,7 +759,7 @@ class NormalizationFactory {
             }
             const invalidEventsDirectiveNames = new Set();
             for (const definedEventsDirectiveName of definedEventsDirectiveNames) {
-                if (!validEventsDirectiveNames.has(definedEventsDirectiveName)) {
+                if (!validEventDirectiveNames.has(definedEventsDirectiveName)) {
                     invalidEventsDirectiveNames.add(definedEventsDirectiveName);
                 }
             }
@@ -670,7 +769,7 @@ class NormalizationFactory {
                     invalidDirectiveNames: [...invalidEventsDirectiveNames],
                 });
             }
-            if (isMutation) {
+            if (operationTypeNode === graphql_1.OperationTypeNode.MUTATION) {
                 const typeString = (0, merge_1.printTypeNode)(fieldData.type);
                 if (typeString !== string_constants_1.NON_NULLABLE_EDFS_PUBLISH_EVENT_RESULT) {
                     invalidResponseTypeNameByMutationPath.set(fieldPath, typeString);
@@ -741,7 +840,7 @@ class NormalizationFactory {
         }
         return true;
     }
-    isStreamConfigurationInputObjectValid(streamConfigurationInputData) {
+    isNatsStreamConfigurationInputObjectValid(streamConfigurationInputData) {
         if (streamConfigurationInputData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
             return false;
         }
@@ -775,9 +874,8 @@ class NormalizationFactory {
                 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);
+            if (data.isRootType) {
+                this.validateEventDrivenRootType(data, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath);
                 continue;
             }
             const keyFieldNames = this.keyFieldNamesByParentTypeName.get(typeName);
@@ -789,17 +887,15 @@ class NormalizationFactory {
             this.validateEventDrivenObjectFields(data.fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath);
         }
         for (const [typeName, data] of this.parentDefinitionDataByTypeName) {
-            // validate edfs__PublishResult and edfs__StreamConfiguration separately
-            if (typeName === string_constants_1.EDFS_PUBLISH_RESULT || typeName === string_constants_1.EDFS_STREAM_CONFIGURATION) {
+            // validate edfs__PublishResult and edfs__NatsStreamConfiguration separately
+            if (typeName === string_constants_1.EDFS_PUBLISH_RESULT || typeName === string_constants_1.EDFS_NATS_STREAM_CONFIGURATION) {
                 continue;
             }
             if (data.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                 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);
+            if (data.isRootType) {
+                this.validateEventDrivenRootType(data, invalidEventsDirectiveDataByRootFieldPath, invalidResponseTypeStringByRootFieldPath, invalidResponseTypeNameByMutationPath);
                 continue;
             }
             const keyFieldNames = this.keyFieldNamesByParentTypeName.get(typeName);
@@ -813,12 +909,14 @@ class NormalizationFactory {
         if (!this.isEdfsPublishResultValid()) {
             errorMessages.push(errors_1.invalidEdfsPublishResultObjectErrorMessage);
         }
-        const streamConfigurationInputData = this.parentDefinitionDataByTypeName.get(string_constants_1.EDFS_STREAM_CONFIGURATION);
-        if (!streamConfigurationInputData) {
-            errorMessages.push(errors_1.undefinedStreamConfigurationInputErrorMessage);
-        }
-        else if (!this.isStreamConfigurationInputObjectValid(streamConfigurationInputData)) {
-            errorMessages.push(errors_1.invalidStreamConfigurationInputErrorMessage);
+        if (this.edfsDirectiveReferences.has(string_constants_1.EDFS_NATS_SUBSCRIBE)) {
+            const streamConfigurationInputData = this.parentDefinitionDataByTypeName.get(string_constants_1.EDFS_NATS_STREAM_CONFIGURATION);
+            if (!streamConfigurationInputData) {
+                errorMessages.push(errors_1.undefinedNatsStreamConfigurationInputErrorMessage);
+            }
+            else if (!this.isNatsStreamConfigurationInputObjectValid(streamConfigurationInputData)) {
+                errorMessages.push(errors_1.invalidNatsStreamConfigurationDefinitionErrorMessage);
+            }
         }
         if (invalidEventsDirectiveDataByRootFieldPath.size > 0) {
             errorMessages.push((0, errors_1.invalidRootTypeFieldEventsDirectivesErrorMessage)(invalidEventsDirectiveDataByRootFieldPath));
@@ -914,10 +1012,22 @@ class NormalizationFactory {
             }
             definitions.push(constants_1.SCOPE_SCALAR_DEFINITION);
         }
-        if (this.isEventDrivenSubgraph) {
-            for (const directiveDefinition of constants_1.EVENT_DRIVEN_DIRECTIVE_DEFINITIONS) {
-                definitions.push(directiveDefinition);
+        for (const directiveName of this.edfsDirectiveReferences) {
+            const directiveDefinition = constants_1.EVENT_DRIVEN_DIRECTIVE_DEFINITIONS_BY_DIRECTIVE_NAME.get(directiveName);
+            if (!directiveDefinition) {
+                // should never happen
+                this.errors.push((0, errors_1.invalidEdfsDirectiveName)(directiveName));
+                continue;
             }
+            definitions.push(directiveDefinition);
+        }
+        // subscriptionFilter is temporarily valid only in an EDG
+        if (this.edfsDirectiveReferences.size > 0 && this.referencedDirectiveNames.has(string_constants_1.SUBSCRIPTION_FILTER)) {
+            this.directiveDefinitionByDirectiveName.set(string_constants_1.SUBSCRIPTION_FILTER, constants_1.SUBSCRIPTION_FILTER_DEFINITION);
+            definitions.push(constants_1.SUBSCRIPTION_FILTER_DEFINITION);
+            definitions.push(constants_1.SUBSCRIPTION_FILTER_CONDITION_DEFINITION);
+            definitions.push(constants_1.SUBSCRIPTION_FIELD_CONDITION_DEFINITION);
+            definitions.push(constants_1.SUBSCRIPTION_FILTER_VALUE_DEFINITION);
         }
         for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
             definitions.push(directiveDefinition);
@@ -1189,7 +1299,7 @@ class NormalizationFactory {
             }
             (0, utils_4.addPersistedDirectiveDefinitionDataByNode)(persistedDirectiveDefinitionDataByDirectiveName, directiveDefinitionNode, this.errors, this.directiveDefinitionByDirectiveName, this.handledRepeatedDirectivesByHostPath, executableLocations, this.subgraphName);
         }
-        if (this.isEventDrivenSubgraph) {
+        if (this.edfsDirectiveReferences.size > 0) {
             this.validateEventDrivenSubgraph();
         }
         if (this.errors.length > 0) {