@wundergraph/composition 0.63.0 → 0.63.2

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

@@ -1185,7 +1185,7 @@ class NormalizationFactory {
         if ((0, utils_1.isValidProvidesParentData)(namedTypeData)) {
             if ((0, utils_3.isUnionDefinitionData)(namedTypeData)) {
                 this.warnings.push((0, warnings_1.providesOnUnionWarning)({
-                    fieldCoords,
+                    directiveCoords: fieldCoords,
                     fieldSet,
                     namedTypeName: fieldNamedTypeName,
                     subgraphName: this.subgraphName,
@@ -1205,7 +1205,18 @@ class NormalizationFactory {
             success: false,
         };
     }
-    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, }) {
+    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, parentData, selection, }) {
+        if ((0, utils_4.isInterfaceDefinitionData)(parentData)) {
+            this.errors.push((0, errors_1.directlyProvidedInterfaceFieldError)({
+                directiveCoords,
+                directiveName,
+                fieldSet,
+                selection,
+                subgraphName: this.subgraphName,
+                targetCoords: currentFieldCoords,
+            }));
+            return;
+        }
         if (this.isSubgraphVersionTwo) {
             this.errors.push((0, errors_1.nonExternalConditionalFieldError)({
                 directiveCoords,
@@ -1221,6 +1232,37 @@ class NormalizationFactory {
          * */
         this.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, this.subgraphName, currentFieldCoords, fieldSet, directiveName));
     }
+    // Returns true if at least one implementation field is @external
+    handleConditionalImplementationField({ fieldCoordsPath, fieldName, fieldPath, interfaceTypeName, isProvides, }) {
+        const implementationTypeNames = this.concreteTypeNamesByAbstractTypeName.get(interfaceTypeName);
+        if (!implementationTypeNames) {
+            return false;
+        }
+        let hasExternalField = false;
+        for (const typeName of implementationTypeNames) {
+            const data = this.parentDefinitionDataByTypeName.get(typeName);
+            if (!(0, utils_3.isObjectDefinitionData)(data)) {
+                continue;
+            }
+            const fieldData = data.fieldDataByName.get(fieldName);
+            if (!fieldData?.directivesByName.has(string_constants_1.EXTERNAL)) {
+                continue;
+            }
+            const externalData = fieldData.externalFieldDataBySubgraphName.get(this.subgraphName);
+            if (!externalData || externalData.isUnconditionallyProvided) {
+                continue;
+            }
+            if (!isProvides) {
+                return true;
+            }
+            (0, utils_5.getValueOrDefault)(this.conditionalFieldDataByCoords, `${typeName}.${fieldName}`, utils_4.newConditionalFieldData).providedBy.push((0, utils_6.newFieldSetConditionData)({
+                fieldCoordinatesPath: [...fieldCoordsPath],
+                fieldPath: [...fieldPath],
+            }));
+            hasExternalField = true;
+        }
+        return hasExternalField;
+    }
     validateConditionalFieldSet(selectionSetParentData, fieldSet, directiveFieldName, isProvides, directiveParentTypeName) {
         // Create a new selection set so that the value can be parsed as a new DocumentNode
         const { error, documentNode } = (0, utils_1.safeParse)('{' + fieldSet + '}');
@@ -1265,17 +1307,29 @@ class NormalizationFactory {
                     fieldCoordsPath.push(currentFieldCoords);
                     fieldPath.push(fieldName);
                     lastFieldName = fieldName;
+                    const isInterfaceParent = (0, utils_4.isInterfaceDefinitionData)(parentData);
                     if (fieldName === string_constants_1.TYPENAME) {
                         if (isProvides) {
                             errorMessages.push((0, errors_1.typeNameAlreadyProvidedErrorMessage)(currentFieldCoords, nf.subgraphName));
                             return graphql_1.BREAK;
                         }
                         if (externalAncestors.size < 1) {
+                            if (isProvides && isInterfaceParent) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
                             nf.#handleNonExternalConditionalField({
                                 currentFieldCoords,
                                 directiveCoords,
                                 directiveName,
                                 fieldSet,
+                                parentData,
+                                selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
                             });
                         }
                         return;
@@ -1304,14 +1358,43 @@ class NormalizationFactory {
                         namedTypeData?.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
                         namedTypeData?.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
                         if (externalAncestors.size < 1 && !isDefinedExternal) {
+                            if (isProvides && isInterfaceParent) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
                             nf.#handleNonExternalConditionalField({
                                 currentFieldCoords,
                                 directiveCoords,
                                 directiveName,
                                 fieldSet,
+                                parentData,
+                                selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
                             });
                             return;
                         }
+                        if (isInterfaceParent) {
+                            if (isProvides) {
+                                nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                                    directiveCoords,
+                                    fieldCoords: currentFieldCoords,
+                                    fieldSet,
+                                    selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                                    subgraphName: nf.subgraphName,
+                                }));
+                            }
+                            nf.handleConditionalImplementationField({
+                                fieldCoordsPath,
+                                fieldName,
+                                fieldPath,
+                                interfaceTypeName: parentData.name,
+                                isProvides,
+                            });
+                        }
                         if (externalAncestors.size < 1 && isUnconditionallyProvided) {
                             // V2 subgraphs return an error when an external key field on an entity extension is provided.
                             if (nf.isSubgraphVersionTwo) {
@@ -1352,13 +1435,35 @@ class NormalizationFactory {
                         }
                         externalAncestors.add(currentFieldCoords);
                     }
-                    if (namedTypeData.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
-                        namedTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
-                        namedTypeData.kind === graphql_1.Kind.UNION_TYPE_DEFINITION) {
-                        shouldDefineSelectionSet = true;
-                        parentDatas.push(namedTypeData);
+                    if (!(0, utils_1.isValidProvidesParentData)(namedTypeData)) {
+                        return;
+                    }
+                    shouldDefineSelectionSet = true;
+                    parentDatas.push(namedTypeData);
+                    if (!isInterfaceParent) {
+                        return;
+                    }
+                    if (isProvides) {
+                        nf.warnings.push((0, warnings_1.providesWithInterfaceFieldSelectionWarning)({
+                            directiveCoords,
+                            fieldCoords: currentFieldCoords,
+                            fieldSet,
+                            selection: fieldPath.length < 2 ? fieldName : `${fieldPath.at(-2)} { ${fieldName} }`,
+                            subgraphName: nf.subgraphName,
+                        }));
+                    }
+                    if (!nf.handleConditionalImplementationField({
+                        fieldCoordsPath,
+                        fieldName,
+                        fieldPath,
+                        interfaceTypeName: parentData.name,
+                        isProvides,
+                    }) ||
+                        externalAncestors.size > 0) {
                         return;
                     }
+                    hasConditionalField = true;
+                    externalAncestors.add(currentFieldCoords);
                 },
                 leave() {
                     externalAncestors.delete(fieldCoordsPath.pop() || '');