@wundergraph/composition 0.56.0 → 0.58.0

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

@@ -305,7 +305,10 @@ class NormalizationFactory {
             if (isAuthenticated) {
                 this.handleAuthenticatedDirective(data, parentTypeName);
             }
-            if (isSemanticNonNull && isField) {
+            if (!isField) {
+                return errorMessages;
+            }
+            if (isSemanticNonNull) {
                 // 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)({
@@ -317,9 +320,12 @@ class NormalizationFactory {
                     data.nullLevelsBySubgraphName.set(this.subgraphName, new Set([0]));
                 }
             }
-            if (isListSize && isField && !(0, utils_4.isTypeNodeListType)(data.type)) {
+            if (isListSize && !(0, utils_4.isTypeNodeListType)(data.type)) {
                 errorMessages.push((0, errors_1.listSizeFieldMustReturnListOrUseSizedFieldsErrorMessage)(directiveCoords, (0, merge_1.printTypeNode)(data.type)));
             }
+            if (!isCost && !isListSize) {
+                this.recordDirectiveWeightOnField({ data: data, definitionData, directiveName, directiveNode });
+            }
             return errorMessages;
         }
         const definedArgumentNames = new Set();
@@ -376,8 +382,13 @@ class NormalizationFactory {
         if (isCost) {
             this.handleCostDirective({ data, directiveCoords, directiveNode, errorMessages });
         }
-        else if (isListSize && isField) {
-            this.handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages });
+        else if (isField) {
+            if (isListSize) {
+                this.handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages });
+            }
+            else {
+                this.recordDirectiveWeightOnField({ data: data, definitionData, directiveName, directiveNode });
+            }
         }
         if (duplicateArgumentNames.size > 0) {
             errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionsErrorMessage)([...duplicateArgumentNames]));
@@ -1733,6 +1744,15 @@ class NormalizationFactory {
         }
         data.nullLevelsBySubgraphName.set(this.subgraphName, levels);
     }
+    getOrCreateFieldWeight(typeName, fieldName) {
+        const fieldCoords = `${typeName}.${fieldName}`;
+        return (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
+            typeName,
+            fieldName,
+            argumentWeights: new Map(),
+            directiveArgumentWeights: new Map(),
+        }));
+    }
     handleCostDirective({ data, directiveCoords, directiveNode, errorMessages }) {
         const weightArg = directiveNode.arguments?.find((arg) => arg.name.value === string_constants_1.WEIGHT);
         if (!weightArg || weightArg.value.kind !== graphql_1.Kind.INT) {
@@ -1756,12 +1776,7 @@ class NormalizationFactory {
                     errorMessages.push((0, errors_1.costOnInterfaceFieldErrorMessage)(directiveCoords));
                     break;
                 }
-                const fieldCoords = `${typeName}.${data.name}`;
-                const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
-                    typeName,
-                    fieldName: data.name,
-                    argumentWeights: new Map(),
-                }));
+                const fieldWeight = this.getOrCreateFieldWeight(typeName, data.name);
                 fieldWeight.weight = weightValue;
                 break;
             }
@@ -1779,28 +1794,61 @@ class NormalizationFactory {
                         errorMessages.push((0, errors_1.costOnInterfaceFieldErrorMessage)(directiveCoords));
                         break;
                     }
-                    const parentFieldCoords = `${typeName}.${ivData.fieldName}`;
-                    const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, parentFieldCoords, () => ({
-                        typeName,
-                        fieldName: ivData.fieldName,
-                        argumentWeights: new Map(),
-                    }));
+                    const fieldWeight = this.getOrCreateFieldWeight(typeName, ivData.fieldName);
                     fieldWeight.argumentWeights.set(ivData.name, weightValue);
                 }
                 else {
                     const typeName = ivData.renamedParentTypeName || ivData.originalParentTypeName;
-                    const fieldCoords = `${typeName}.${ivData.name}`;
-                    const fieldWeight = (0, utils_5.getValueOrDefault)(this.costs.fieldWeights, fieldCoords, () => ({
-                        typeName,
-                        fieldName: ivData.name,
-                        argumentWeights: new Map(),
-                    }));
+                    const fieldWeight = this.getOrCreateFieldWeight(typeName, ivData.name);
                     fieldWeight.weight = weightValue;
                 }
                 break;
             }
         }
     }
+    recordDirectiveWeightOnField({ data, definitionData, directiveName, directiveNode, }) {
+        // This method walks every argument defined on the directive and records a directive weight
+        // on the field only when all these conditions hold:
+        // 1. The argument of the directive has a cost weight assigned
+        // 2. The argument is non-null
+        // 3. The parent type is not an interface type.
+        const typeName = data.renamedParentTypeName || data.originalParentTypeName;
+        const parentTypeData = this.parentDefinitionDataByTypeName.get(typeName);
+        // Directive argument weights should only be recorded for concrete type fields.
+        if (!parentTypeData || parentTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+            return;
+        }
+        // Determine which arguments are non-null on this directive usage.
+        // Record the DirectiveArgument coords if its argument has an explicit non-null value or
+        // if it has a default value and was not explicitly set to null.
+        const suppliedArgNodeByName = new Map();
+        for (const arg of directiveNode.arguments ?? []) {
+            suppliedArgNodeByName.set(arg.name.value, arg.value);
+        }
+        for (const [argName, argData] of definitionData.argumentTypeNodeByName) {
+            const coords = `${directiveName}.${argName}`;
+            const argWeight = this.costs.directiveArgumentWeights.get(coords);
+            // Bail if the argName argument does not have cost attached to it.
+            if (argWeight === undefined) {
+                continue;
+            }
+            // Check if this argument is non-null at the usage site:
+            const argNode = suppliedArgNodeByName.get(argName);
+            if (argNode) {
+                if (argNode.kind === graphql_1.Kind.NULL) {
+                    continue;
+                }
+            }
+            else if (!argData.defaultValue || argData.defaultValue.kind === graphql_1.Kind.NULL) {
+                continue;
+            }
+            const fieldWeight = this.getOrCreateFieldWeight(typeName, data.name);
+            // Accumulate across directive usages so that repeatable directives on the same
+            // field are charged once per usage.
+            const existingWeight = fieldWeight.directiveArgumentWeights.get(coords) ?? 0;
+            fieldWeight.directiveArgumentWeights.set(coords, existingWeight + argWeight);
+        }
+    }
     handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages }) {
         const args = directiveNode.arguments;
         if (!args) {