@wundergraph/composition 0.37.1 → 0.37.3

package/dist/v1/normalization/normalization-factory.js

@@ -41,7 +41,6 @@ function normalizeSubgraph(document, subgraphName, internalGraph) {
 class NormalizationFactory {
     argumentName = '';
     authorizationDataByParentTypeName = new Map();
-    childName = '';
     concreteTypeNamesByAbstractTypeName = new Map();
     conditionalFieldDataByCoords = new Map();
     configurationDataByTypeName = new Map();
@@ -100,13 +99,12 @@ class NormalizationFactory {
             operationTypes: new Map(),
         };
     }
-    validateInputNamedType(namedType) {
-        if (constants_1.BASE_SCALARS.has(namedType)) {
+    validateInputNamedType(namedTypeName) {
+        if (constants_1.BASE_SCALARS.has(namedTypeName)) {
             return { hasUnhandledError: false, typeString: '' };
         }
-        const parentData = this.parentDefinitionDataByTypeName.get(namedType);
+        const parentData = this.parentDefinitionDataByTypeName.get(namedTypeName);
         if (!parentData) {
-            this.errors.push((0, errors_1.undefinedTypeError)(namedType));
             return { hasUnhandledError: false, typeString: '' };
         }
         switch (parentData.kind) {
@@ -122,6 +120,9 @@ class NormalizationFactory {
         const invalidArguments = [];
         for (const [argumentName, argumentNode] of fieldData.argumentDataByArgumentName) {
             const namedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(argumentNode.type);
+            if (!constants_1.BASE_SCALARS.has(namedTypeName)) {
+                this.referencedTypeNames.add(namedTypeName);
+            }
             const { hasUnhandledError, typeString } = this.validateInputNamedType(namedTypeName);
             if (hasUnhandledError) {
                 invalidArguments.push({
@@ -184,6 +185,7 @@ class NormalizationFactory {
             return;
         }
         const scopesArgument = directiveNode.arguments[0];
+        // @TODO list coercion
         if (scopesArgument.name.value !== string_constants_2.SCOPES || scopesArgument.value.kind !== graphql_1.Kind.LIST) {
             return;
         }
@@ -728,6 +730,7 @@ class NormalizationFactory {
     }
     addFieldDataByNode(fieldDataByFieldName, node, argumentDataByArgumentName, directivesByDirectiveName) {
         const name = node.name.value;
+        const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
         const fieldCoords = `${this.originalParentTypeName}.${name}`;
         const { isExternal, isShareable } = (0, utils_4.isNodeExternalOrShareable)(node, !this.isSubgraphVersionTwo, directivesByDirectiveName);
         const fieldData = {
@@ -736,6 +739,7 @@ class NormalizationFactory {
             externalFieldDataBySubgraphName: new Map([
                 [this.subgraphName, (0, utils_4.newExternalFieldData)(isExternal)],
             ]),
+            federatedCoords: `${parentTypeName}.${name}`,
             isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
             isShareableBySubgraphName: new Map([[this.subgraphName, isShareable]]),
             kind: graphql_1.Kind.FIELD_DEFINITION,
@@ -744,12 +748,15 @@ class NormalizationFactory {
             node: (0, ast_1.getMutableFieldNode)(node, fieldCoords, this.errors),
             originalParentTypeName: this.originalParentTypeName,
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
-            renamedParentTypeName: this.renamedParentTypeName || this.originalParentTypeName,
+            renamedParentTypeName: parentTypeName,
             subgraphNames: new Set([this.subgraphName]),
             type: (0, ast_1.getMutableTypeNode)(node.type, fieldCoords, this.errors),
             directivesByDirectiveName,
             description: (0, utils_1.formatDescription)(node.description),
         };
+        if (!constants_1.BASE_SCALARS.has(fieldData.namedTypeName)) {
+            this.referencedTypeNames.add(fieldData.namedTypeName);
+        }
         this.extractConfigureDescriptionsData(fieldData);
         fieldDataByFieldName.set(name, fieldData);
         return fieldData;
@@ -768,10 +775,11 @@ class NormalizationFactory {
             isArgument,
             kind: isArgument ? graphql_1.Kind.ARGUMENT : graphql_1.Kind.INPUT_VALUE_DEFINITION,
             name,
+            namedTypeName: (0, ast_1.getTypeNodeNamedTypeName)(node.type),
             node: (0, ast_1.getMutableInputValueNode)(node, originalPath, this.errors),
-            originalPath,
+            originalCoords: originalPath,
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
-            renamedPath: renamedPath || originalPath,
+            federatedCoords: renamedPath || originalPath,
             requiredSubgraphNames: new Set((0, utils_4.isTypeRequired)(node.type) ? [this.subgraphName] : []),
             subgraphNames: new Set([this.subgraphName]),
             type: (0, ast_1.getMutableTypeNode)(node.type, originalPath, this.errors),
@@ -892,6 +900,7 @@ class NormalizationFactory {
                 return;
             }
             this.setParentDataExtensionType(parentData, extensionType);
+            parentData.isInaccessible ||= directivesByDirectiveName.has(string_constants_2.INACCESSIBLE);
             parentData.subgraphNames.add(this.subgraphName);
             parentData.description ||= (0, utils_1.formatDescription)('description' in node ? node.description : undefined);
             this.extractConfigureDescriptionsData(parentData);
@@ -903,6 +912,7 @@ class NormalizationFactory {
             directivesByDirectiveName,
             extensionType,
             enumValueDataByValueName: new Map(),
+            isInaccessible: directivesByDirectiveName.has(string_constants_2.INACCESSIBLE),
             kind: graphql_1.Kind.ENUM_TYPE_DEFINITION,
             name: typeName,
             node: (0, ast_1.getMutableEnumNode)(node.name),
@@ -1402,10 +1412,13 @@ class NormalizationFactory {
         const implementationErrorsMap = new Map();
         const invalidImplementationTypeStringByTypeName = new Map();
         let doesInterfaceImplementItself = false;
-        for (const interfaceName of data.implementedInterfaceTypeNames) {
-            const interfaceData = this.parentDefinitionDataByTypeName.get(interfaceName);
+        for (const interfaceTypeName of data.implementedInterfaceTypeNames) {
+            const interfaceData = this.parentDefinitionDataByTypeName.get(interfaceTypeName);
+            // This check is so undefined type errors are not improperly propagated
+            if (constants_1.BASE_SCALARS.has(interfaceTypeName)) {
+                this.referencedTypeNames.add(interfaceTypeName);
+            }
             if (!interfaceData) {
-                this.errors.push((0, errors_1.undefinedTypeError)(interfaceName));
                 continue;
             }
             if (interfaceData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
@@ -1485,7 +1498,7 @@ class NormalizationFactory {
                 }
             }
             if (hasErrors) {
-                implementationErrorsMap.set(interfaceName, implementationErrors);
+                implementationErrorsMap.set(interfaceTypeName, implementationErrors);
             }
         }
         if (invalidImplementationTypeStringByTypeName.size > 0) {
@@ -1516,7 +1529,7 @@ class NormalizationFactory {
             return;
         }
         const overrideDataForSubgraph = (0, utils_5.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
-        (0, utils_5.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName || data.originalParentTypeName, () => new Set()).add(data.name);
+        (0, utils_5.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName, () => new Set()).add(data.name);
     }
     handleRequiresScopesDirective({ directiveCoords, orScopes, requiredScopes }) {
         if (orScopes.length > utils_3.maxOrScopes) {
@@ -1533,7 +1546,7 @@ class NormalizationFactory {
             }
         }
     }
-    getKafkaPublishConfiguration(directive, argumentDataByArgumentName, errorMessages) {
+    getKafkaPublishConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages) {
         const topics = [];
         let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
@@ -1560,14 +1573,15 @@ class NormalizationFactory {
         if (errorMessages.length > 0) {
             return;
         }
-        return { fieldName: this.childName, providerId, providerType: string_constants_2.PROVIDER_TYPE_KAFKA, topics, type: string_constants_2.PUBLISH };
+        return { fieldName, providerId, providerType: string_constants_2.PROVIDER_TYPE_KAFKA, topics, type: string_constants_2.PUBLISH };
     }
-    getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages) {
+    getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages) {
         const topics = [];
         let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
                 case string_constants_2.TOPICS: {
+                    //@TODO list coercion
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
                         errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_2.TOPICS));
                         continue;
@@ -1596,14 +1610,14 @@ class NormalizationFactory {
             return;
         }
         return {
-            fieldName: this.childName,
+            fieldName,
             providerId,
             providerType: string_constants_2.PROVIDER_TYPE_KAFKA,
             topics: topics,
             type: string_constants_2.SUBSCRIBE,
         };
     }
-    getNatsPublishAndRequestConfiguration(eventType, directive, argumentDataByArgumentName, errorMessages) {
+    getNatsPublishAndRequestConfiguration(eventType, directive, argumentDataByArgumentName, fieldName, errorMessages) {
         const subjects = [];
         let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         for (const argumentNode of directive.arguments || []) {
@@ -1630,9 +1644,9 @@ class NormalizationFactory {
         if (errorMessages.length > 0) {
             return;
         }
-        return { fieldName: this.childName, providerId, providerType: string_constants_2.PROVIDER_TYPE_NATS, subjects, type: eventType };
+        return { fieldName, providerId, providerType: string_constants_2.PROVIDER_TYPE_NATS, subjects, type: eventType };
     }
-    getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages) {
+    getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages) {
         const subjects = [];
         let providerId = string_constants_2.DEFAULT_EDFS_PROVIDER_ID;
         let consumerInactiveThreshold = integer_constants_1.DEFAULT_CONSUMER_INACTIVE_THRESHOLD;
@@ -1641,8 +1655,9 @@ class NormalizationFactory {
         for (const argumentNode of directive.arguments || []) {
             switch (argumentNode.name.value) {
                 case string_constants_2.SUBJECTS: {
+                    // @TODO list coercion
                     if (argumentNode.value.kind !== graphql_1.Kind.LIST) {
-                        // errorMessages.push(invalidEventSubjectsErrorMessage(SUBJECTS));
+                        errorMessages.push((0, errors_1.invalidEventSubjectsErrorMessage)(string_constants_2.SUBJECTS));
                         continue;
                     }
                     for (const value of argumentNode.value.values) {
@@ -1745,7 +1760,7 @@ class NormalizationFactory {
             this.warnings.push((0, warnings_1.consumerInactiveThresholdInvalidValueWarning)(this.subgraphName, 'The value has been set to 0. This means the consumer will remain indefinitely active until its manual deletion.'));
         }
         return {
-            fieldName: this.childName,
+            fieldName,
             providerId,
             providerType: string_constants_2.PROVIDER_TYPE_NATS,
             subjects,
@@ -1766,14 +1781,14 @@ class NormalizationFactory {
             return;
         }
         const parentTypeName = this.renamedParentTypeName || this.originalParentTypeName;
-        const fieldPath = `${parentTypeName}.${node.name.value}`;
+        const fieldCoords = `${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_2.SUBSCRIPTION_FILTER) {
                 continue;
             }
             if (!isSubscription) {
-                this.errors.push((0, errors_1.invalidSubscriptionFilterLocationError)(fieldPath));
+                this.errors.push((0, errors_1.invalidSubscriptionFilterLocationError)(fieldCoords));
                 return;
             }
         }
@@ -1783,34 +1798,35 @@ class NormalizationFactory {
         if (!node.directives) {
             return;
         }
-        const fieldPath = `${this.renamedParentTypeName || this.originalParentTypeName}.${this.childName}`;
+        const fieldName = node.name.value;
+        const fieldCoords = `${this.renamedParentTypeName || this.originalParentTypeName}.${fieldName}`;
         for (const directive of node.directives) {
             const errorMessages = [];
             let eventConfiguration;
             switch (directive.name.value) {
                 case string_constants_2.EDFS_KAFKA_PUBLISH:
-                    eventConfiguration = this.getKafkaPublishConfiguration(directive, argumentDataByArgumentName, errorMessages);
+                    eventConfiguration = this.getKafkaPublishConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages);
                     break;
                 case string_constants_2.EDFS_KAFKA_SUBSCRIBE:
-                    eventConfiguration = this.getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages);
+                    eventConfiguration = this.getKafkaSubscribeConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages);
                     break;
                 case string_constants_2.EDFS_NATS_PUBLISH: {
-                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.PUBLISH, directive, argumentDataByArgumentName, errorMessages);
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.PUBLISH, directive, argumentDataByArgumentName, fieldName, errorMessages);
                     break;
                 }
                 case string_constants_2.EDFS_NATS_REQUEST: {
-                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.REQUEST, directive, argumentDataByArgumentName, errorMessages);
+                    eventConfiguration = this.getNatsPublishAndRequestConfiguration(string_constants_2.REQUEST, directive, argumentDataByArgumentName, fieldName, errorMessages);
                     break;
                 }
                 case string_constants_2.EDFS_NATS_SUBSCRIBE: {
-                    eventConfiguration = this.getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, errorMessages);
+                    eventConfiguration = this.getNatsSubscribeConfiguration(directive, argumentDataByArgumentName, fieldName, errorMessages);
                     break;
                 }
                 default:
                     continue;
             }
             if (errorMessages.length > 0) {
-                this.errors.push((0, errors_1.invalidEventDirectiveError)(directive.name.value, fieldPath, errorMessages));
+                this.errors.push((0, errors_1.invalidEventDirectiveError)(directive.name.value, fieldCoords, errorMessages));
                 continue;
             }
             // should never happen
@@ -1855,7 +1871,7 @@ class NormalizationFactory {
         }
         const validEventDirectiveNames = this.getValidEventsDirectiveNamesForOperationTypeNode(operationTypeNode);
         for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
-            const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
+            const fieldCoords = `${fieldData.originalParentTypeName}.${fieldName}`;
             const definedEventsDirectiveNames = new Set();
             for (const eventsDirectiveName of string_constants_1.EVENT_DIRECTIVE_NAMES) {
                 if (fieldData.directivesByDirectiveName.has(eventsDirectiveName)) {
@@ -1869,7 +1885,7 @@ class NormalizationFactory {
                 }
             }
             if (definedEventsDirectiveNames.size < 1 || invalidEventsDirectiveNames.size > 0) {
-                invalidEventsDirectiveDataByRootFieldPath.set(fieldPath, {
+                invalidEventsDirectiveDataByRootFieldPath.set(fieldCoords, {
                     definesDirectives: definedEventsDirectiveNames.size > 0,
                     invalidDirectiveNames: [...invalidEventsDirectiveNames],
                 });
@@ -1877,7 +1893,7 @@ class NormalizationFactory {
             if (operationTypeNode === graphql_1.OperationTypeNode.MUTATION) {
                 const typeString = (0, merge_1.printTypeNode)(fieldData.type);
                 if (typeString !== string_constants_2.NON_NULLABLE_EDFS_PUBLISH_EVENT_RESULT) {
-                    invalidResponseTypeNameByMutationPath.set(fieldPath, typeString);
+                    invalidResponseTypeNameByMutationPath.set(fieldCoords, typeString);
                 }
                 continue;
             }
@@ -1893,7 +1909,7 @@ class NormalizationFactory {
                 }
             }
             if (!isValid || fieldTypeString !== expectedTypeString) {
-                invalidResponseTypeStringByRootFieldPath.set(fieldPath, fieldTypeString);
+                invalidResponseTypeStringByRootFieldPath.set(fieldCoords, fieldTypeString);
             }
         }
     }
@@ -1911,14 +1927,14 @@ class NormalizationFactory {
     }
     validateEventDrivenObjectFields(fieldDataByFieldName, keyFieldNames, nonExternalKeyFieldNameByFieldPath, nonKeyFieldNameByFieldPath) {
         for (const [fieldName, fieldData] of fieldDataByFieldName) {
-            const fieldPath = `${fieldData.originalParentTypeName}.${fieldName}`;
+            const fieldCoords = `${fieldData.originalParentTypeName}.${fieldName}`;
             if (keyFieldNames.has(fieldName)) {
                 if (!fieldData.externalFieldDataBySubgraphName.get(this.subgraphName)?.isDefinedExternal) {
-                    nonExternalKeyFieldNameByFieldPath.set(fieldPath, fieldName);
+                    nonExternalKeyFieldNameByFieldPath.set(fieldCoords, fieldName);
                 }
                 continue;
             }
-            nonKeyFieldNameByFieldPath.set(fieldPath, fieldName);
+            nonKeyFieldNameByFieldPath.set(fieldCoords, fieldName);
         }
     }
     isEdfsPublishResultValid() {
@@ -2548,6 +2564,10 @@ class NormalizationFactory {
             const defaultTypeName = (0, utils_5.getOrThrowError)(utils_1.operationTypeNodeToDefaultType, operationType, string_constants_2.OPERATION_TO_DEFAULT);
             // If an operation type name was not declared, use the default
             const operationTypeName = operationTypeNode ? (0, ast_1.getTypeNodeNamedTypeName)(operationTypeNode.type) : defaultTypeName;
+            // This check is so undefined type errors are not improperly propagated
+            if (constants_1.BASE_SCALARS.has(operationTypeName)) {
+                this.referencedTypeNames.add(operationTypeName);
+            }
             // If a custom type is used, the default type should not be defined
             if (operationTypeName !== defaultTypeName && this.parentDefinitionDataByTypeName.has(defaultTypeName)) {
                 this.errors.push((0, errors_1.invalidRootTypeDefinitionError)(operationType, operationTypeName, defaultTypeName));
@@ -2556,9 +2576,8 @@ class NormalizationFactory {
             const objectData = this.parentDefinitionDataByTypeName.get(operationTypeName);
             // operationTypeNode is truthy if an operation type was explicitly declared
             if (operationTypeNode) {
-                // If the type is not defined in the schema, it's always an error
+                // If the type is not defined in the schema, it will be handled when checking references
                 if (!objectData) {
-                    this.errors.push((0, errors_1.undefinedTypeError)(operationTypeName));
                     continue;
                 }
                 // Add the explicitly defined type to the map for the federation-factory
@@ -2574,13 +2593,6 @@ class NormalizationFactory {
             }
             if (objectData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
                 this.errors.push((0, errors_1.operationDefinitionError)(operationTypeName, operationType, objectData.kind));
-                continue;
-            }
-            for (const fieldData of objectData.fieldDataByFieldName.values()) {
-                const fieldTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
-                if (!constants_1.BASE_SCALARS.has(fieldTypeName) && !this.parentDefinitionDataByTypeName.has(fieldTypeName)) {
-                    this.errors.push((0, errors_1.undefinedTypeError)(fieldTypeName));
-                }
             }
         }
         for (const referencedTypeName of this.referencedTypeNames) {
@@ -2754,14 +2766,14 @@ function batchNormalize(subgraphs) {
                     (0, utils_5.addIterableValuesToSet)(fieldNames, existingFieldNames);
                 }
                 for (const fieldName of fieldNames) {
-                    const fieldPath = `${originalParentTypeName}.${fieldName}`;
-                    const sourceSubgraphs = overrideSourceSubgraphNamesByFieldPath.get(fieldPath);
+                    const fieldCoords = `${originalParentTypeName}.${fieldName}`;
+                    const sourceSubgraphs = overrideSourceSubgraphNamesByFieldPath.get(fieldCoords);
                     if (!sourceSubgraphs) {
-                        overrideSourceSubgraphNamesByFieldPath.set(fieldPath, [subgraphName]);
+                        overrideSourceSubgraphNamesByFieldPath.set(fieldCoords, [subgraphName]);
                         continue;
                     }
                     sourceSubgraphs.push(subgraphName);
-                    duplicateOverriddenFieldPaths.add(fieldPath);
+                    duplicateOverriddenFieldPaths.add(fieldCoords);
                 }
             }
         }