@wundergraph/composition 0.58.2 → 0.59.0

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

@@ -1801,6 +1801,12 @@ class NormalizationFactory {
             sizedFields: [],
             requireOneSlicingArgument: true, // per IBM cost spec
         };
+        /**
+         * For each accepted slicing argument, capture the full resolved chain:
+         * (argument + each intermediate input field + leaf).
+         * Later we check the assumedSize against the default value of every element of the chain.
+         */
+        const slicingArgChainByPath = new Map();
         for (const argumentNode of args) {
             const argumentName = argumentNode.name.value;
             // type validation handled upstream
@@ -1830,18 +1836,61 @@ class NormalizationFactory {
                         if (valueNode.kind !== graphql_1.Kind.STRING) {
                             continue;
                         }
-                        const slicingArgName = valueNode.value;
-                        const argData = data.argumentDataByName.get(slicingArgName);
+                        // slicingArgPath could be just an argument "inputA" or a dot-path "inputA.page.first".
+                        const slicingArgPath = valueNode.value;
+                        const segments = slicingArgPath.split(string_constants_1.LITERAL_PERIOD);
+                        // Reject empty segments (e.g. "", "a.", ".b", "a..b").
+                        if (segments.length === 0 || segments.some((s) => s.length === 0)) {
+                            errorMessages.push((0, errors_1.listSizeSlicingArgumentMalformedPathErrorMessage)(directiveCoords, slicingArgPath));
+                            continue;
+                        }
+                        // First segment should be valid argument name:
+                        const firstSegment = segments[0];
+                        const argData = data.argumentDataByName.get(firstSegment);
                         if (!argData) {
-                            errorMessages.push((0, errors_1.listSizeInvalidSlicingArgumentErrorMessage)(directiveCoords, slicingArgName));
+                            errorMessages.push((0, errors_1.listSizeInvalidSlicingArgumentErrorMessage)(directiveCoords, slicingArgPath));
+                            continue;
+                        }
+                        /**
+                         * Walk the rest of the path in the slicingArgument.
+                         * `current` tracks the input value reached so far:
+                         * the argument itself for a flat path, or the nested input field for each step of a
+                         * dot-path. After the loop it is the leaf, which must be Int/Int!.
+                         */
+                        let current = argData;
+                        const chain = [argData];
+                        let isPathInvalid = false;
+                        for (let i = 1; i < segments.length; i++) {
+                            // Non-leaf step: `current` must unwrap to an Input Object. Lists are rejected here.
+                            const unwrapped = current.type.kind === graphql_1.Kind.NON_NULL_TYPE ? current.type.type : current.type;
+                            const parentTypeData = this.parentDefinitionDataByTypeName.get(current.namedTypeName);
+                            if (unwrapped.kind === graphql_1.Kind.LIST_TYPE ||
+                                !parentTypeData ||
+                                parentTypeData.kind !== graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                                errorMessages.push((0, errors_1.listSizeSlicingArgumentSegmentNotInputObjectErrorMessage)(directiveCoords, slicingArgPath, current.name, (0, merge_1.printTypeNode)(current.type)));
+                                isPathInvalid = true;
+                                break;
+                            }
+                            const inputValue = parentTypeData.inputValueDataByName.get(segments[i]);
+                            if (!inputValue) {
+                                errorMessages.push((0, errors_1.listSizeSlicingArgumentSegmentNotFoundErrorMessage)(directiveCoords, slicingArgPath, segments[i], current.namedTypeName));
+                                isPathInvalid = true;
+                                break;
+                            }
+                            current = inputValue;
+                            chain.push(inputValue);
+                        }
+                        if (isPathInvalid) {
                             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)));
+                        // Leaf check: the final value must be Int or Int!
+                        const unwrappedType = current.type.kind === graphql_1.Kind.NON_NULL_TYPE ? current.type.type : current.type;
+                        if (unwrappedType.kind === graphql_1.Kind.LIST_TYPE || current.namedTypeName !== string_constants_1.INT_SCALAR) {
+                            errorMessages.push((0, errors_1.listSizeSlicingArgumentNotIntErrorMessage)(directiveCoords, slicingArgPath, (0, merge_1.printTypeNode)(current.type)));
                             continue;
                         }
-                        listSizeConfig.slicingArguments.push(slicingArgName);
+                        listSizeConfig.slicingArguments.push(slicingArgPath);
+                        slicingArgChainByPath.set(slicingArgPath, chain);
                     }
                     break;
                 }
@@ -1897,10 +1946,44 @@ class NormalizationFactory {
                 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));
+                /**
+                 * When assumedSize is set together with slicingArguments, the slicing argument must not have
+                 * a default leaf value in any element of the slicingArgument's chain.
+                 * That will be checked for all slicing Arguments.
+                 * For example, if the query is defined like this:
+                 *    search(a: SearchInput): [Book]
+                 *        @listSize(assumedSize: 50, slicingArguments: ["a.b.c"], requireOneSlicingArgument: false)
+                 * any of those defaults are forbidden:
+                 *     input SearchInput { b: PaginationInput = { c: 10 } }
+                 *     input PaginationInput { c: Int = 10 }
+                 * Notably, this query definition is also forbidden with the @listSize above:
+                 *     search(a: SearchInput = { b: { c: 10 } }): [Book]
+                 * A default along the chain only matters if it actually supplies a value for the leaf:
+                 * walk the remaining tail through the default's AST and reject only when the walk resolves.
+                 * E.g. `a: SearchInput = { b: {} }` is allowed, and the leaf stays undefined.
+                 */
+                for (const slicingArgPath of listSizeConfig.slicingArguments) {
+                    const chain = slicingArgChainByPath.get(slicingArgPath);
+                    if (!chain) {
+                        continue;
+                    }
+                    const segments = slicingArgPath.split(string_constants_1.LITERAL_PERIOD);
+                    // Outer loop: which default are we starting from?
+                    for (let i = 0; i < chain.length; i++) {
+                        let value = chain[i].defaultValue;
+                        // Inner loop: try to find a defined leaf in the chain:
+                        for (let j = i + 1; j < segments.length; j++) {
+                            if (!value || value.kind !== graphql_1.Kind.OBJECT) {
+                                value = undefined;
+                                break;
+                            }
+                            const field = value.fields.find((f) => f.name.value === segments[j]);
+                            value = field?.value;
+                        }
+                        if (value !== undefined) {
+                            errorMessages.push((0, errors_1.listSizeAssumedSizeSlicingArgDefaultErrorMessage)(directiveCoords, slicingArgPath));
+                            break;
+                        }
                     }
                 }
             }