@wundergraph/composition 0.44.0 → 0.45.0

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

@@ -248,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, []));
@@ -257,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();
@@ -279,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,
@@ -289,6 +306,14 @@ class NormalizationFactory {
                 });
                 continue;
             }
+            if (isSemanticNonNull && isField) {
+                this.handleSemanticNonNullDirective({
+                    data,
+                    directiveNode,
+                    errorMessages,
+                });
+                continue;
+            }
             if (!isRequiresScopes || argumentName !== string_constants_2.SCOPES) {
                 continue;
             }
@@ -672,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,
@@ -1477,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);