@wundergraph/composition 0.48.4 → 0.48.5

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

@@ -1106,20 +1106,51 @@ class NormalizationFactory {
         }
         const fieldData = (0, utils_5.getOrThrowError)(parentData.fieldDataByName, fieldName, `${parentTypeName}.fieldDataByFieldName`);
         const fieldNamedTypeName = (0, ast_1.getTypeNodeNamedTypeName)(fieldData.node.type);
+        const fieldCoords = `${parentTypeName}.${fieldName}`;
+        if (constants_1.BASE_SCALARS.has(fieldNamedTypeName)) {
+            return {
+                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)({
+                    fieldCoords,
+                    responseType: fieldNamedTypeName,
+                    subgraphName: this.subgraphName,
+                }),
+            };
+        }
         const namedTypeData = this.parentDefinitionDataByTypeName.get(fieldNamedTypeName);
         // This error should never happen
         if (!namedTypeData) {
             return {
-                errorString: (0, errors_1.unknownNamedTypeErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+                errorString: (0, errors_1.unknownNamedTypeErrorMessage)(fieldCoords, fieldNamedTypeName),
             };
         }
+        // @TODO handle abstract types and fragments
         if (namedTypeData.kind !== graphql_1.Kind.INTERFACE_TYPE_DEFINITION && namedTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
             return {
-                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)(`${parentTypeName}.${fieldName}`, fieldNamedTypeName),
+                errorString: (0, errors_1.incompatibleTypeWithProvidesErrorMessage)({
+                    fieldCoords,
+                    responseType: fieldNamedTypeName,
+                    subgraphName: this.subgraphName,
+                }),
             };
         }
         return { fieldSetParentData: namedTypeData };
     }
+    #handleNonExternalConditionalField({ currentFieldCoords, directiveCoords, directiveName, fieldSet, }) {
+        if (this.isSubgraphVersionTwo) {
+            this.errors.push((0, errors_1.nonExternalConditionalFieldError)({
+                directiveCoords,
+                directiveName,
+                fieldSet,
+                subgraphName: this.subgraphName,
+                targetCoords: currentFieldCoords,
+            }));
+            return;
+        }
+        /* In V1, @requires and @provides do not need to declare any part of the field set @external.
+         * It would appear that any such non-external fields are treated as if they are non-conditionally provided.
+         * */
+        this.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, this.subgraphName, currentFieldCoords, fieldSet, directiveName));
+    }
     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 + '}');
@@ -1164,6 +1195,21 @@ class NormalizationFactory {
                     fieldCoordsPath.push(currentFieldCoords);
                     fieldPath.push(fieldName);
                     lastFieldName = fieldName;
+                    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) {
+                            nf.#handleNonExternalConditionalField({
+                                currentFieldCoords,
+                                directiveCoords,
+                                directiveName,
+                                fieldSet,
+                            });
+                        }
+                        return;
+                    }
                     const fieldData = parentData.fieldDataByName.get(fieldName);
                     // undefined if the field does not exist on the parent
                     if (!fieldData) {
@@ -1188,14 +1234,12 @@ class NormalizationFactory {
                         namedTypeData?.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
                         namedTypeData?.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION) {
                         if (externalAncestors.size < 1 && !isDefinedExternal) {
-                            if (nf.isSubgraphVersionTwo) {
-                                nf.errors.push((0, errors_1.nonExternalConditionalFieldError)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
-                                return;
-                            }
-                            /* In V1, @requires and @provides do not need to declare any part of the field set @external.
-                             * It would appear that any such non-external fields are treated as if they are non-conditionally provided.
-                             * */
-                            nf.warnings.push((0, warnings_1.nonExternalConditionalFieldWarning)(directiveCoords, nf.subgraphName, currentFieldCoords, fieldSet, directiveName));
+                            nf.#handleNonExternalConditionalField({
+                                currentFieldCoords,
+                                directiveCoords,
+                                directiveName,
+                                fieldSet,
+                            });
                             return;
                         }
                         if (externalAncestors.size < 1 && isUnconditionallyProvided) {
@@ -1315,6 +1359,10 @@ class NormalizationFactory {
                             errorMessages.push((0, errors_1.unparsableFieldSetSelectionErrorMessage)(fieldSet, lastFieldName));
                             return graphql_1.BREAK;
                         }
+                        if (lastFieldName === string_constants_1.TYPENAME) {
+                            errorMessages.push((0, errors_1.invalidSelectionSetDefinitionErrorMessage)(fieldSet, fieldCoordsPath, string_constants_1.STRING_SCALAR, (0, utils_5.kindToNodeType)(graphql_1.Kind.SCALAR_TYPE_DEFINITION)));
+                            return graphql_1.BREAK;
+                        }
                         const fieldData = parentData.fieldDataByName.get(lastFieldName);
                         if (!fieldData) {
                             errorMessages.push((0, errors_1.undefinedFieldInFieldSetErrorMessage)(fieldSet, parentData.name, lastFieldName));