@wundergraph/composition 0.52.0 → 0.54.0

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

@@ -26,16 +26,20 @@ const integer_constants_1 = require("../../utils/integer-constants");
 const utils_5 = require("../../utils/utils");
 const utils_6 = require("../../router-configuration/utils");
 const non_directive_definitions_1 = require("../constants/non-directive-definitions");
-function normalizeSubgraphFromString(subgraphSDL, noLocation = true) {
-    const { error, documentNode } = (0, utils_1.safeParse)(subgraphSDL, noLocation);
+function normalizeSubgraphFromString({ noLocation, options, sdlString, }) {
+    const { error, documentNode } = (0, utils_1.safeParse)(sdlString, noLocation);
     if (error || !documentNode) {
         return { errors: [(0, errors_1.subgraphInvalidSyntaxError)(error)], success: false, warnings: [] };
     }
-    const normalizationFactory = new NormalizationFactory(new graph_1.Graph());
+    const normalizationFactory = new NormalizationFactory({ internalGraph: new graph_1.Graph(), options });
     return normalizationFactory.normalize(documentNode);
 }
-function normalizeSubgraph(document, subgraphName, internalGraph) {
-    const normalizationFactory = new NormalizationFactory(internalGraph || new graph_1.Graph(), subgraphName);
+function normalizeSubgraph({ document, internalGraph, options, subgraphName, }) {
+    const normalizationFactory = new NormalizationFactory({
+        internalGraph: internalGraph || new graph_1.Graph(),
+        options,
+        subgraphName,
+    });
     return normalizationFactory.normalize(document);
 }
 class NormalizationFactory {
@@ -44,6 +48,12 @@ class NormalizationFactory {
     concreteTypeNamesByAbstractTypeName = new Map();
     conditionalFieldDataByCoords = new Map();
     configurationDataByTypeName = new Map();
+    costs = {
+        fieldWeights: new Map(),
+        listSizes: new Map(),
+        typeWeights: new Map(),
+        directiveArgumentWeights: new Map(),
+    };
     customDirectiveDefinitionByName = new Map();
     definedDirectiveNames = new Set();
     directiveDefinitionByName = new Map();
@@ -66,6 +76,7 @@ class NormalizationFactory {
     keyFieldSetDatasByTypeName = new Map();
     lastParentNodeKind = graphql_1.Kind.NULL;
     lastChildNodeKind = graphql_1.Kind.NULL;
+    options;
     parentTypeNamesWithAuthDirectives = new Set();
     keyFieldSetsByEntityTypeNameByFieldCoords = new Map();
     keyFieldNamesByParentTypeName = new Map();
@@ -83,7 +94,8 @@ class NormalizationFactory {
     unvalidatedExternalFieldCoords = new Set();
     usesEdfsNatsStreamConfiguration = false;
     warnings = [];
-    constructor(internalGraph, subgraphName) {
+    constructor({ internalGraph, options, subgraphName }) {
+        this.options = options ?? {};
         this.subgraphName = subgraphName || string_constants_1.NOT_APPLICABLE;
         this.internalGraph = internalGraph;
         this.internalGraph.setSubgraphName(this.subgraphName);
@@ -257,7 +269,9 @@ 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_1.AUTHENTICATED;
+        const isCost = directiveName === string_constants_1.COST;
         const isField = (0, utils_4.isFieldData)(data);
+        const isListSize = directiveName === string_constants_1.LIST_SIZE;
         const isOverride = directiveName === string_constants_1.OVERRIDE;
         const isRequiresScopes = directiveName === string_constants_1.REQUIRES_SCOPES;
         const isSemanticNonNull = directiveName === string_constants_1.SEMANTIC_NON_NULL;
@@ -280,6 +294,9 @@ class NormalizationFactory {
                     data.nullLevelsBySubgraphName.set(this.subgraphName, new Set([0]));
                 }
             }
+            if (isListSize && isField && !(0, utils_4.isTypeNodeListType)(data.type)) {
+                errorMessages.push((0, errors_1.listSizeFieldMustReturnListOrUseSizedFieldsErrorMessage)(directiveCoords, (0, merge_1.printTypeNode)(data.type)));
+            }
             return errorMessages;
         }
         const definedArgumentNames = new Set();
@@ -333,6 +350,12 @@ class NormalizationFactory {
                 requiredScopes,
             });
         }
+        if (isCost) {
+            this.handleCostDirective({ data, directiveCoords, directiveNode, errorMessages });
+        }
+        else if (isListSize && isField) {
+            this.handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages });
+        }
         if (duplicateArgumentNames.size > 0) {
             errorMessages.push((0, errors_1.duplicateDirectiveArgumentDefinitionsErrorMessage)([...duplicateArgumentNames]));
         }
@@ -652,6 +675,37 @@ class NormalizationFactory {
         }
         return output;
     }
+    // extracts cost weights from @cost directives applied to arguments of directive definitions.
+    // It works on nodes of this kind: "directive @myDirective(arg1: Int @cost(weight: 5)) on FIELD"
+    extractDirectiveArgumentCosts(node) {
+        if (!node.arguments) {
+            return;
+        }
+        const directiveName = node.name.value;
+        for (const argNode of node.arguments) {
+            if (!argNode.directives) {
+                continue;
+            }
+            for (const directive of argNode.directives) {
+                if (directive.name.value !== string_constants_1.COST) {
+                    continue;
+                }
+                const weightArg = directive.arguments?.find((a) => a.name.value === string_constants_1.WEIGHT);
+                if (!weightArg) {
+                    continue;
+                }
+                if (weightArg.value.kind !== graphql_1.Kind.INT) {
+                    const directiveCoords = `@${directiveName}(${argNode.name.value}: ...)`;
+                    this.errors.push((0, errors_1.invalidDirectiveError)(string_constants_1.COST, directiveCoords, '1st', [
+                        (0, errors_1.invalidArgumentValueErrorMessage)((0, graphql_1.print)(weightArg.value), `@${string_constants_1.COST}`, string_constants_1.WEIGHT, 'Int!'),
+                    ]));
+                    continue;
+                }
+                const weightValue = parseInt(weightArg.value.value, 10);
+                this.costs.directiveArgumentWeights.set(`${directiveName}.${argNode.name.value}`, weightValue);
+            }
+        }
+    }
     // returns true if the directive is custom; otherwise, false
     addDirectiveDefinitionDataByNode(node) {
         const name = node.name.value;
@@ -660,6 +714,7 @@ class NormalizationFactory {
             return false;
         }
         this.definedDirectiveNames.add(name);
+        this.extractDirectiveArgumentCosts(node);
         // Normalize federation directives by replacing them with predefined definitions
         const definition = constants_1.V2_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME.get(name);
         // Add the V2 directive definitions regardless of use so the subgraph can be recognised as a V2 subgraph.
@@ -1631,6 +1686,195 @@ class NormalizationFactory {
         }
         data.nullLevelsBySubgraphName.set(this.subgraphName, levels);
     }
+    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) {
+            return; // type validation handled upstream
+        }
+        const weightValue = parseInt(weightArg.value.value, 10);
+        switch (data.kind) {
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                this.costs.typeWeights.set(data.name, weightValue);
+                break;
+            case graphql_1.Kind.FIELD_DEFINITION: {
+                const typeName = data.renamedParentTypeName || data.originalParentTypeName;
+                const parentTypeData = this.parentDefinitionDataByTypeName.get(typeName);
+                if (!parentTypeData) {
+                    // undefined types are handled elsewhere
+                    break;
+                }
+                if (parentTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                    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(),
+                }));
+                fieldWeight.weight = weightValue;
+                break;
+            }
+            case graphql_1.Kind.INPUT_VALUE_DEFINITION:
+            case graphql_1.Kind.ARGUMENT: {
+                const ivData = data;
+                if (ivData.isArgument && ivData.fieldName) {
+                    const typeName = ivData.renamedParentTypeName || ivData.originalParentTypeName;
+                    const parentTypeData = this.parentDefinitionDataByTypeName.get(typeName);
+                    if (!parentTypeData) {
+                        // undefined types are handled elsewhere
+                        break;
+                    }
+                    if (parentTypeData.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION) {
+                        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(),
+                    }));
+                    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(),
+                    }));
+                    fieldWeight.weight = weightValue;
+                }
+                break;
+            }
+        }
+    }
+    handleListSizeDirective({ data, directiveCoords, directiveNode, errorMessages }) {
+        const args = directiveNode.arguments;
+        if (!args) {
+            return;
+        }
+        let hasSizedFields = false;
+        const typeName = data.renamedParentTypeName || data.originalParentTypeName;
+        const listSizeConfig = {
+            typeName,
+            fieldName: data.name,
+            slicingArguments: [],
+            sizedFields: [],
+            requireOneSlicingArgument: true, // per IBM cost spec
+        };
+        for (const argumentNode of args) {
+            const argumentName = argumentNode.name.value;
+            // type validation handled upstream
+            switch (argumentName) {
+                case string_constants_1.ASSUMED_SIZE:
+                    if (argumentNode.value.kind === graphql_1.Kind.INT) {
+                        listSizeConfig.assumedSize = parseInt(argumentNode.value.value, 10);
+                    }
+                    break;
+                case string_constants_1.REQUIRE_ONE_SLICING_ARGUMENT:
+                    if (argumentNode.value.kind === graphql_1.Kind.BOOLEAN) {
+                        listSizeConfig.requireOneSlicingArgument = argumentNode.value.value;
+                    }
+                    break;
+                case string_constants_1.SLICING_ARGUMENTS: {
+                    let argumentValues;
+                    if (argumentNode.value.kind === graphql_1.Kind.LIST) {
+                        argumentValues = argumentNode.value.values;
+                    }
+                    else if (argumentNode.value.kind === graphql_1.Kind.STRING) {
+                        argumentValues = [argumentNode.value];
+                    }
+                    else {
+                        continue;
+                    }
+                    for (const valueNode of argumentValues) {
+                        if (valueNode.kind !== graphql_1.Kind.STRING) {
+                            continue;
+                        }
+                        const slicingArgName = valueNode.value;
+                        const argData = data.argumentDataByName.get(slicingArgName);
+                        if (!argData) {
+                            errorMessages.push((0, errors_1.listSizeInvalidSlicingArgumentErrorMessage)(directiveCoords, slicingArgName));
+                            continue;
+                        }
+                        const unwrappedType = argData.type.kind === graphql_1.Kind.NON_NULL_TYPE ? argData.type.type : argData.type;
+                        if (unwrappedType.kind === graphql_1.Kind.LIST_TYPE || argData.namedTypeName !== string_constants_1.INT_SCALAR) {
+                            errorMessages.push((0, errors_1.listSizeSlicingArgumentNotIntErrorMessage)(directiveCoords, slicingArgName, (0, merge_1.printTypeNode)(argData.type)));
+                            continue;
+                        }
+                        listSizeConfig.slicingArguments.push(slicingArgName);
+                    }
+                    break;
+                }
+                case string_constants_1.SIZED_FIELDS: {
+                    let fieldValues;
+                    if (argumentNode.value.kind === graphql_1.Kind.LIST) {
+                        fieldValues = argumentNode.value.values;
+                    }
+                    else if (argumentNode.value.kind === graphql_1.Kind.STRING) {
+                        fieldValues = [argumentNode.value];
+                    }
+                    else {
+                        continue;
+                    }
+                    if (fieldValues.length < 1) {
+                        continue;
+                    }
+                    hasSizedFields = true;
+                    const returnTypeName = data.namedTypeName;
+                    const returnTypeData = this.parentDefinitionDataByTypeName.get(returnTypeName);
+                    if (!returnTypeData || !(0, utils_4.isParentDataCompositeOutputType)(returnTypeData)) {
+                        errorMessages.push((0, errors_1.listSizeSizedFieldsInvalidReturnTypeErrorMessage)(directiveCoords, returnTypeName));
+                        continue;
+                    }
+                    for (const valueNode of fieldValues) {
+                        if (valueNode.kind !== graphql_1.Kind.STRING) {
+                            continue;
+                        }
+                        const sizedFieldName = valueNode.value;
+                        const fieldData = returnTypeData.fieldDataByName.get(sizedFieldName);
+                        if (!fieldData) {
+                            errorMessages.push((0, errors_1.listSizeSizedFieldNotFoundErrorMessage)(directiveCoords, sizedFieldName, returnTypeName));
+                            continue;
+                        }
+                        if (!(0, utils_4.isTypeNodeListType)(fieldData.type)) {
+                            errorMessages.push((0, errors_1.listSizeSizedFieldNotListErrorMessage)(directiveCoords, sizedFieldName, returnTypeName, (0, merge_1.printTypeNode)(fieldData.type)));
+                            continue;
+                        }
+                        listSizeConfig.sizedFields.push(sizedFieldName);
+                    }
+                    break;
+                }
+            }
+        }
+        if (!hasSizedFields && !(0, utils_4.isTypeNodeListType)(data.type)) {
+            errorMessages.push((0, errors_1.listSizeFieldMustReturnListOrUseSizedFieldsErrorMessage)(directiveCoords, (0, merge_1.printTypeNode)(data.type)));
+        }
+        if (hasSizedFields && (0, utils_4.isTypeNodeListType)(data.type)) {
+            errorMessages.push((0, errors_1.listSizeSizedFieldsOnListsErrorMessage)(directiveCoords, (0, merge_1.printTypeNode)(data.type)));
+        }
+        if (listSizeConfig.assumedSize !== undefined && listSizeConfig.slicingArguments.length > 0) {
+            if (listSizeConfig.requireOneSlicingArgument) {
+                errorMessages.push((0, errors_1.listSizeAssumedSizeWithRequiredSlicingArgumentErrorMessage)(directiveCoords));
+            }
+            else {
+                for (const slicingArgName of listSizeConfig.slicingArguments) {
+                    const argData = data.argumentDataByName.get(slicingArgName);
+                    if (argData?.defaultValue) {
+                        errorMessages.push((0, errors_1.listSizeAssumedSizeSlicingArgDefaultErrorMessage)(directiveCoords, slicingArgName));
+                    }
+                }
+            }
+        }
+        const fieldCoords = `${typeName}.${data.name}`;
+        this.costs.listSizes.set(fieldCoords, listSizeConfig);
+    }
     extractRequiredScopes({ directiveCoords, orScopes, requiredScopes }) {
         if (orScopes.length > constants_1.MAX_OR_SCOPES) {
             this.invalidORScopesCoords.add(directiveCoords);
@@ -2639,7 +2883,7 @@ class NormalizationFactory {
         this.validateDirectives(this.schemaData, string_constants_1.SCHEMA);
         const schemaNode = this.getSchemaNodeByData(this.schemaData);
         /* Schema extension orphans are not supported on old routers.
-         * Consequently, it is a breaking change that requires a new composition version, and hat composition version
+         * Consequently, it is a breaking change that requires a new composition version, and that composition version
          * would only be compatible with newer routers that support schema extension orphans.
          * For now, only a valid schema definition node is pushed.
          */
@@ -2903,6 +3147,7 @@ class NormalizationFactory {
             concreteTypeNamesByAbstractTypeName: this.concreteTypeNamesByAbstractTypeName,
             conditionalFieldDataByCoordinates: this.conditionalFieldDataByCoords,
             configurationDataByTypeName: this.configurationDataByTypeName,
+            costs: this.costs,
             directiveDefinitionByName: this.directiveDefinitionByName,
             entityDataByTypeName: this.entityDataByTypeName,
             entityInterfaces: this.entityInterfaceDataByTypeName,
@@ -2926,7 +3171,7 @@ class NormalizationFactory {
     }
 }
 exports.NormalizationFactory = NormalizationFactory;
-function batchNormalize(subgraphs) {
+function batchNormalize({ options, subgraphs }) {
     const authorizationDataByParentTypeName = new Map();
     const concreteTypeNamesByAbstractTypeName = new Map();
     const entityDataByTypeName = new Map();
@@ -2955,7 +3200,12 @@ function batchNormalize(subgraphs) {
         if (!subgraph.name) {
             invalidNameErrorMessages.push((0, errors_1.invalidSubgraphNameErrorMessage)(i, subgraphName));
         }
-        const normalizationResult = normalizeSubgraph(subgraph.definitions, subgraph.name, internalGraph);
+        const normalizationResult = normalizeSubgraph({
+            document: subgraph.definitions,
+            internalGraph,
+            options,
+            subgraphName,
+        });
         if (normalizationResult.warnings.length > 0) {
             warnings.push(...normalizationResult.warnings);
         }
@@ -3004,6 +3254,7 @@ function batchNormalize(subgraphs) {
             internalSubgraphBySubgraphName.set(subgraphName, {
                 conditionalFieldDataByCoordinates: normalizationResult.conditionalFieldDataByCoordinates,
                 configurationDataByTypeName: normalizationResult.configurationDataByTypeName,
+                costs: normalizationResult.costs,
                 definitions: normalizationResult.subgraphAST,
                 directiveDefinitionByName: normalizationResult.directiveDefinitionByName,
                 entityInterfaces: normalizationResult.entityInterfaces,