@wundergraph/composition 0.43.3 → 0.45.0

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

@@ -47,6 +47,7 @@ class NormalizationFactory {
     definedDirectiveNames = new Set();
     directiveDefinitionByDirectiveName = new Map();
     directiveDefinitionDataByDirectiveName = (0, utils_2.initializeDirectiveDefinitionDatas)();
+    doesParentObjectRequireFetchReasons = false;
     edfsDirectiveReferences = new Set();
     errors = [];
     entityDataByTypeName = new Map();
@@ -207,14 +208,18 @@ class NormalizationFactory {
         }
     }
     addInheritedDirectivesToFieldData(fieldDirectivesByDirectiveName, inheritedDirectiveNames) {
-        if (this.isParentObjectShareable && !fieldDirectivesByDirectiveName.has(string_constants_2.SHAREABLE)) {
-            fieldDirectivesByDirectiveName.set(string_constants_2.SHAREABLE, [(0, utils_5.generateSimpleDirective)(string_constants_2.SHAREABLE)]);
-            inheritedDirectiveNames.add(string_constants_2.SHAREABLE);
-        }
         if (this.isParentObjectExternal && !fieldDirectivesByDirectiveName.has(string_constants_2.EXTERNAL)) {
             fieldDirectivesByDirectiveName.set(string_constants_2.EXTERNAL, [(0, utils_5.generateSimpleDirective)(string_constants_2.EXTERNAL)]);
             inheritedDirectiveNames.add(string_constants_2.EXTERNAL);
         }
+        if (this.doesParentObjectRequireFetchReasons && !fieldDirectivesByDirectiveName.has(string_constants_2.REQUIRE_FETCH_REASONS)) {
+            fieldDirectivesByDirectiveName.set(string_constants_2.REQUIRE_FETCH_REASONS, [(0, utils_5.generateSimpleDirective)(string_constants_2.REQUIRE_FETCH_REASONS)]);
+            inheritedDirectiveNames.add(string_constants_2.REQUIRE_FETCH_REASONS);
+        }
+        if (this.isParentObjectShareable && !fieldDirectivesByDirectiveName.has(string_constants_2.SHAREABLE)) {
+            fieldDirectivesByDirectiveName.set(string_constants_2.SHAREABLE, [(0, utils_5.generateSimpleDirective)(string_constants_2.SHAREABLE)]);
+            inheritedDirectiveNames.add(string_constants_2.SHAREABLE);
+        }
         return fieldDirectivesByDirectiveName;
     }
     extractDirectives(node, directivesByDirectiveName) {
@@ -234,6 +239,7 @@ class NormalizationFactory {
                 continue;
             }
             this.isParentObjectExternal ||= directiveName === string_constants_2.EXTERNAL;
+            this.doesParentObjectRequireFetchReasons ||= directiveName === string_constants_2.REQUIRE_FETCH_REASONS;
             this.isParentObjectShareable ||= directiveName === string_constants_2.SHAREABLE;
         }
         return directivesByDirectiveName;
@@ -242,8 +248,10 @@ class NormalizationFactory {
         const directiveName = directiveNode.name.value;
         const parentTypeName = data.kind === graphql_1.Kind.FIELD_DEFINITION ? data.renamedParentTypeName || data.originalParentTypeName : data.name;
         const isAuthenticated = directiveName === string_constants_2.AUTHENTICATED;
+        const isField = (0, utils_4.isFieldData)(data);
         const isOverride = directiveName === string_constants_2.OVERRIDE;
         const isRequiresScopes = directiveName === string_constants_2.REQUIRES_SCOPES;
+        const isSemanticNonNull = directiveName === string_constants_2.SEMANTIC_NON_NULL;
         if (!directiveNode.arguments || directiveNode.arguments.length < 1) {
             if (definitionData.requiredArgumentNames.size > 0) {
                 errorMessages.push((0, errors_1.undefinedRequiredArgumentsErrorMessage)(directiveName, requiredArgumentNames, []));
@@ -251,6 +259,18 @@ class NormalizationFactory {
             if (isAuthenticated) {
                 this.handleAuthenticatedDirective(data, parentTypeName);
             }
+            if (isSemanticNonNull && isField) {
+                // The default argument for levels is [0], so a non-null wrapper is invalid.
+                if ((0, utils_4.isTypeRequired)(data.type)) {
+                    errorMessages.push((0, errors_1.semanticNonNullLevelsNonNullErrorMessage)({
+                        typeString: (0, merge_1.printTypeNode)(data.type),
+                        value: '0',
+                    }));
+                }
+                else {
+                    data.nullLevelsBySubgraphName.set(this.subgraphName, new Set([0]));
+                }
+            }
             return errorMessages;
         }
         const definedArgumentNames = new Set();
@@ -273,8 +293,11 @@ class NormalizationFactory {
                 errorMessages.push((0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(argumentNode.value), `@${directiveName}`, argumentName, (0, merge_1.printTypeNode)(argumentData.typeNode)));
                 continue;
             }
-            // The directive location validation means the kind check should be unnecessary
-            if (isOverride && data.kind === graphql_1.Kind.FIELD_DEFINITION) {
+            /* Individual directives are handled in the loop because they validate a single argument, and duplicate
+             * arguments would short-circuit.
+             * The directive location validation means the node kind check should be unnecessary
+             * */
+            if (isOverride && isField) {
                 this.handleOverrideDirective({
                     data,
                     directiveCoords,
@@ -283,6 +306,14 @@ class NormalizationFactory {
                 });
                 continue;
             }
+            if (isSemanticNonNull && isField) {
+                this.handleSemanticNonNullDirective({
+                    data,
+                    directiveNode,
+                    errorMessages,
+                });
+                continue;
+            }
             if (!isRequiresScopes || argumentName !== string_constants_2.SCOPES) {
                 continue;
             }
@@ -666,6 +697,7 @@ class NormalizationFactory {
             namedTypeKind: constants_1.BASE_SCALARS.has(namedTypeName) ? graphql_1.Kind.SCALAR_TYPE_DEFINITION : graphql_1.Kind.NULL,
             namedTypeName,
             node: (0, ast_1.getMutableFieldNode)(node, fieldCoords, this.errors),
+            nullLevelsBySubgraphName: new Map(),
             originalParentTypeName: this.originalParentTypeName,
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
             renamedParentTypeName: parentTypeName,
@@ -784,7 +816,7 @@ class NormalizationFactory {
     upsertObjectDataByNode(node, isRealExtension = false) {
         const typeName = node.name.value;
         const parentData = this.parentDefinitionDataByTypeName.get(typeName);
-        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName || new Map());
+        const directivesByDirectiveName = this.extractDirectives(node, parentData?.directivesByDirectiveName ?? new Map());
         const isRootType = this.isTypeNameRootType(typeName);
         const extensionType = this.getNodeExtensionType(isRealExtension, directivesByDirectiveName, isRootType);
         this.addInterfaceObjectFieldsByNode(node);
@@ -816,6 +848,7 @@ class NormalizationFactory {
             name: typeName,
             node: (0, ast_1.getMutableObjectNode)(node.name),
             persistedDirectivesData: (0, utils_4.newPersistedDirectivesData)(),
+            requireFetchReasonsFieldNames: new Set(),
             renamedTypeName: this.getRenamedRootTypeName(typeName),
             subgraphNames: new Set([this.subgraphName]),
             description: (0, utils_1.formatDescription)('description' in node ? node.description : undefined),
@@ -1470,6 +1503,62 @@ class NormalizationFactory {
         const overrideDataForSubgraph = (0, utils_5.getValueOrDefault)(this.overridesByTargetSubgraphName, targetSubgraphName, () => new Map());
         (0, utils_5.getValueOrDefault)(overrideDataForSubgraph, data.renamedParentTypeName, () => new Set()).add(data.name);
     }
+    handleSemanticNonNullDirective({ data, directiveNode, errorMessages }) {
+        const nonNullIndices = new Set();
+        let currentType = data.node.type;
+        let index = 0;
+        while (currentType) {
+            switch (currentType.kind) {
+                case graphql_1.Kind.LIST_TYPE: {
+                    index += 1;
+                    currentType = currentType.type;
+                    break;
+                }
+                case graphql_1.Kind.NON_NULL_TYPE: {
+                    nonNullIndices.add(index);
+                    currentType = currentType.type;
+                    break;
+                }
+                default: {
+                    currentType = null;
+                    break;
+                }
+            }
+        }
+        const levelsArg = directiveNode.arguments?.find((arg) => arg.name.value === string_constants_2.LEVELS);
+        if (!levelsArg || levelsArg.value.kind !== graphql_1.Kind.LIST) {
+            // Should never happen because the argument will have just been validated.
+            errorMessages.push(errors_1.semanticNonNullArgumentErrorMessage);
+            return;
+        }
+        const values = levelsArg.value.values;
+        const typeString = (0, merge_1.printTypeNode)(data.type);
+        const levels = new Set();
+        for (const { value } of values) {
+            const int = parseInt(value, 10);
+            if (Number.isNaN(int)) {
+                errorMessages.push((0, errors_1.semanticNonNullLevelsNaNIndexErrorMessage)(value));
+                continue;
+            }
+            if (int < 0 || int > index) {
+                errorMessages.push((0, errors_1.semanticNonNullLevelsIndexOutOfBoundsErrorMessage)({
+                    maxIndex: index,
+                    typeString,
+                    value,
+                }));
+                continue;
+            }
+            if (!nonNullIndices.has(int)) {
+                levels.add(int);
+                continue;
+            }
+            errorMessages.push((0, errors_1.semanticNonNullLevelsNonNullErrorMessage)({
+                typeString,
+                value,
+            }));
+        }
+        data.nullLevelsBySubgraphName.set(this.subgraphName, levels);
+    }
     extractRequiredScopes({ directiveCoords, orScopes, requiredScopes }) {
         if (orScopes.length > constants_1.MAX_OR_SCOPES) {
             this.invalidORScopesCoords.add(directiveCoords);
@@ -2059,11 +2148,6 @@ class NormalizationFactory {
             this.parentDefinitionDataByTypeName.delete(string_constants_2.EDFS_NATS_STREAM_CONFIGURATION);
             definitions.push(constants_1.EDFS_NATS_STREAM_CONFIGURATION_DEFINITION);
         }
-        if (this.referencedDirectiveNames.has(string_constants_2.LINK)) {
-            definitions.push(constants_1.LINK_DEFINITION);
-            definitions.push(constants_1.LINK_IMPORT_DEFINITION);
-            definitions.push(constants_1.LINK_PURPOSE_DEFINITION);
-        }
         if (invalidEventsDirectiveDataByRootFieldPath.size > 0) {
             errorMessages.push((0, errors_1.invalidRootTypeFieldEventsDirectivesErrorMessage)(invalidEventsDirectiveDataByRootFieldPath));
         }
@@ -2436,12 +2520,20 @@ class NormalizationFactory {
             definitions.push(constants_1.SUBSCRIPTION_FIELD_CONDITION_DEFINITION);
             definitions.push(constants_1.SUBSCRIPTION_FILTER_VALUE_DEFINITION);
         }
+        if (this.referencedDirectiveNames.has(string_constants_2.LINK)) {
+            definitions.push(constants_1.LINK_DEFINITION);
+            definitions.push(constants_1.LINK_IMPORT_DEFINITION);
+            definitions.push(constants_1.LINK_PURPOSE_DEFINITION);
+        }
         if (this.referencedDirectiveNames.has(string_constants_2.CONFIGURE_DESCRIPTION)) {
             definitions.push(constants_1.CONFIGURE_DESCRIPTION_DEFINITION);
         }
         if (this.referencedDirectiveNames.has(string_constants_2.CONFIGURE_CHILD_DESCRIPTIONS)) {
             definitions.push(constants_1.CONFIGURE_CHILD_DESCRIPTIONS_DEFINITION);
         }
+        if (this.referencedDirectiveNames.has(string_constants_2.REQUIRE_FETCH_REASONS)) {
+            definitions.push(constants_1.REQUIRE_FETCH_REASONS_DEFINITION);
+        }
         for (const directiveDefinition of this.customDirectiveDefinitions.values()) {
             definitions.push(directiveDefinition);
         }
@@ -2566,6 +2658,9 @@ class NormalizationFactory {
                     if (parentData.fieldDataByName.size < 1 && !(0, utils_2.isNodeQuery)(parentTypeName, operationTypeNode)) {
                         this.errors.push((0, errors_1.noFieldDefinitionsError)((0, utils_5.kindToNodeType)(parentData.kind), parentTypeName));
                     }
+                    if (isObject && parentData.requireFetchReasonsFieldNames.size > 0) {
+                        configurationData.requireFetchReasonsFieldNames = [...parentData.requireFetchReasonsFieldNames];
+                    }
                     break;
                 case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
                     if (parentData.extensionType === types_1.ExtensionType.REAL) {