Limit errors in get_variable_values()

Replicates graphql/graphql-js@14f260b

Author: Cito

README.md

@@ -16,7 +16,7 @@ The current version 3.0.0a2 of GraphQL-core is up-to-date
 with GraphQL.js version 14.4.2.
 
 All parts of the API are covered by an extensive test suite
-of currently 1918 unit tests.
+of currently 1925 unit tests.
 
 
 ## Documentation

docs/modules/pyutils.rst

@@ -28,3 +28,4 @@ PyUtils
 .. autoclass:: FrozenDict
 .. autoclass:: Path
    :members:
+.. autofunction:: print_path_list

docs/modules/utilities.rst

@@ -68,6 +68,10 @@ type system:
 
 Coerce a Python value to a GraphQL type, or produce errors:
 
+.. autofunction:: coerce_input_value
+
+Deprecated, use :func:`coerce_input_value`:
+
 .. autofunction:: coerce_value
 
 Concatenate multiple ASTs together:

src/graphql/__init__.py

@@ -360,6 +360,8 @@
     # GraphQL type system.
     TypeInfo,
     # Coerce a Python value to a GraphQL type, or produce errors.
+    coerce_input_value,
+    # Deprecated: use coerce_input_value
     coerce_value,
     # Concatenates multiple ASTs together.
     concat_ast,
@@ -648,6 +650,7 @@
     "value_from_ast_untyped",
     "ast_from_value",
     "TypeInfo",
+    "coerce_input_value",
     "coerce_value",
     "concat_ast",
     "separate_operations",

src/graphql/execution/execute.py

@@ -276,6 +276,7 @@ def build(
             schema,
             operation.variable_definitions or FrozenList(),
             raw_variable_values or {},
+            max_errors=50,
         )
 
         if isinstance(coerced_variable_values, list):

src/graphql/execution/values.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Union, cast
 
 from ..error import GraphQLError, INVALID
 from ..language import (
@@ -14,7 +14,7 @@
     VariableNode,
     print_ast,
 )
-from ..pyutils import inspect, FrozenList
+from ..pyutils import inspect, print_path_list, FrozenList
 from ..type import (
     GraphQLDirective,
     GraphQLField,
@@ -23,7 +23,7 @@
     is_input_type,
     is_non_null_type,
 )
-from ..utilities import coerce_value, type_from_ast, value_from_ast
+from ..utilities import coerce_input_value, type_from_ast, value_from_ast
 
 __all__ = ["get_variable_values", "get_argument_values", "get_directive_values"]
 
@@ -35,6 +35,7 @@ def get_variable_values(
     schema: GraphQLSchema,
     var_def_nodes: FrozenList[VariableDefinitionNode],
     inputs: Dict[str, Any],
+    max_errors: int = None,
 ) -> CoercedVariableValues:
     """Get coerced variable values based on provided definitions.
 
@@ -43,6 +44,31 @@ def get_variable_values(
     the variable definitions, a GraphQLError will be thrown.
     """
     errors: List[GraphQLError] = []
+
+    def on_error(error: GraphQLError):
+        if max_errors is not None and len(errors) >= max_errors:
+            raise GraphQLError(
+                "Too many errors processing variables,"
+                " error limit reached. Execution aborted."
+            )
+        errors.append(error)
+
+    try:
+        coerced = coerce_variable_values(schema, var_def_nodes, inputs, on_error)
+        if not errors:
+            return coerced
+    except GraphQLError as e:
+        errors.append(e)
+
+    return errors
+
+
+def coerce_variable_values(
+    schema: GraphQLSchema,
+    var_def_nodes: FrozenList[VariableDefinitionNode],
+    inputs: Dict[str, Any],
+    on_error: Callable[[GraphQLError], None],
+):
     coerced_values: Dict[str, Any] = {}
     for var_def_node in var_def_nodes:
         var_name = var_def_node.variable.name.value
@@ -51,7 +77,7 @@ def get_variable_values(
             # Must use input types for variables. This should be caught during
             # validation, however is checked again here for safety.
             var_type_str = print_ast(var_def_node.type)
-            errors.append(
+            on_error(
                 GraphQLError(
                     f"Variable '${var_name}' expected value of type '{var_type_str}'"
                     " which cannot be used as an input type.",
@@ -69,7 +95,7 @@ def get_variable_values(
 
             if is_non_null_type(var_type):
                 var_type_str = inspect(var_type)
-                errors.append(
+                on_error(
                     GraphQLError(
                         f"Variable '${var_name}' of required type '{var_type_str}'"
                         " was not provided.",
@@ -81,7 +107,7 @@ def get_variable_values(
         value = inputs[var_name]
         if value is None and is_non_null_type(var_type):
             var_type_str = inspect(var_type)
-            errors.append(
+            on_error(
                 GraphQLError(
                     f"Variable '${var_name}' of non-null type '{var_type_str}'"
                     " must not be null.",
@@ -90,20 +116,26 @@ def get_variable_values(
             )
             continue
 
-        coerced = coerce_value(value, var_type, var_def_node)
-        coercion_errors = coerced.errors
-        if coercion_errors:
-            for error in coercion_errors:
-                error.message = (
-                    f"Variable '${var_name}' got invalid"
-                    f" value {inspect(value)}; {error.message}"
+        def on_input_value_error(
+            path: List[Union[str, int]], invalid_value: Any, error: GraphQLError
+        ):
+            invalid_str = inspect(invalid_value)
+            prefix = f"Variable '${var_name}' got invalid value {invalid_str}"
+            if path:
+                prefix += f" at '{var_name}{print_path_list(path)}'"
+            on_error(
+                GraphQLError(
+                    prefix + "; " + error.message,
+                    var_def_node,
+                    original_error=error.original_error,
                 )
-            errors.extend(coercion_errors)
-            continue
+            )
 
-        coerced_values[var_name] = coerced.value
+        coerced_values[var_name] = coerce_input_value(
+            value, var_type, on_input_value_error
+        )
 
-    return errors or coerced_values
+    return coerced_values
 
 
 def get_argument_values(

src/graphql/pyutils/__init__.py

@@ -25,6 +25,7 @@
 from .frozen_list import FrozenList
 from .frozen_dict import FrozenDict
 from .path import Path
+from .print_path_list import print_path_list
 
 __all__ = [
     "camel_to_snake",
@@ -46,4 +47,5 @@
     "FrozenList",
     "FrozenDict",
     "Path",
+    "print_path_list",
 ]

src/graphql/pyutils/print_path_list.py

@@ -0,0 +1,6 @@
+from typing import Sequence, Union
+
+
+def print_path_list(path: Sequence[Union[str, int]]):
+    """Build a string describing the path."""
+    return "".join(f"[{key}]" if isinstance(key, int) else f".{key}" for key in path)

src/graphql/utilities/__init__.py

@@ -53,6 +53,9 @@
 from .type_info import TypeInfo
 
 # Coerce a Python value to a GraphQL type, or produce errors.
+from .coerce_input_value import coerce_input_value
+
+# deprecated: use coerce_input_value
 from .coerce_value import coerce_value
 
 # Concatenate multiple ASTs together.
@@ -95,6 +98,7 @@
     "build_ast_schema",
     "build_client_schema",
     "build_schema",
+    "coerce_input_value",
     "coerce_value",
     "concat_ast",
     "do_types_overlap",

src/graphql/utilities/coerce_input_value.py

@@ -0,0 +1,165 @@
+from typing import Any, Callable, Dict, Iterable, List, Union, cast
+
+
+from ..error import GraphQLError, INVALID
+from ..pyutils import Path, did_you_mean, inspect, print_path_list, suggestion_list
+from ..type import (
+    GraphQLEnumType,
+    GraphQLInputObjectType,
+    GraphQLInputType,
+    GraphQLList,
+    GraphQLScalarType,
+    is_enum_type,
+    is_input_object_type,
+    is_list_type,
+    is_non_null_type,
+    is_scalar_type,
+    GraphQLNonNull,
+)
+
+__all__ = ["coerce_input_value"]
+
+
+OnErrorCB = Callable[[List[Union[str, int]], Any, GraphQLError], None]
+
+
+def default_on_error(
+    path: List[Union[str, int]], invalid_value: Any, error: GraphQLError
+) -> None:
+    error_prefix = "Invalid value " + inspect(invalid_value)
+    if path:
+        error_prefix += f" at 'value{print_path_list(path)}': "
+    error.message = error_prefix + ": " + error.message
+    raise error
+
+
+def coerce_input_value(
+    input_value: Any,
+    type_: GraphQLInputType,
+    on_error: OnErrorCB = default_on_error,
+    path: Path = None,
+) -> Any:
+    """Coerce a Python value given a GraphQL Input Type."""
+    if is_non_null_type(type_):
+        if input_value is not None and input_value is not INVALID:
+            type_ = cast(GraphQLNonNull, type_)
+            return coerce_input_value(input_value, type_.of_type, on_error, path)
+        on_error(
+            path.as_list() if path else [],
+            input_value,
+            GraphQLError(
+                f"Expected non-nullable type {inspect(type_)} not to be None."
+            ),
+        )
+        return INVALID
+
+    if input_value is None or input_value is INVALID:
+        # Explicitly return the value null.
+        return None
+
+    if is_list_type(type_):
+        type_ = cast(GraphQLList, type_)
+        item_type = type_.of_type
+        if isinstance(input_value, Iterable) and not isinstance(input_value, str):
+            coerced_list: List[Any] = []
+            append_item = coerced_list.append
+            for index, item_value in enumerate(input_value):
+                append_item(
+                    coerce_input_value(
+                        item_value, item_type, on_error, Path(path, index)
+                    )
+                )
+            return coerced_list
+        # Lists accept a non-list value as a list of one.
+        return [coerce_input_value(input_value, item_type, on_error, path)]
+
+    if is_input_object_type(type_):
+        type_ = cast(GraphQLInputObjectType, type_)
+        if not isinstance(input_value, dict):
+            on_error(
+                path.as_list() if path else [],
+                input_value,
+                GraphQLError(f"Expected type {type_.name} to be a dict."),
+            )
+            return INVALID
+
+        coerced_dict: Dict[str, Any] = {}
+        fields = type_.fields
+
+        for field_name, field in fields.items():
+            field_value = input_value.get(field_name, INVALID)
+
+            if field_value is INVALID:
+                if field.default_value is not INVALID:
+                    # Use out name as name if it exists (extension of GraphQL.js).
+                    coerced_dict[field.out_name or field_name] = field.default_value
+                elif is_non_null_type(field.type):
+                    type_str = inspect(field.type)
+                    on_error(
+                        path.as_list() if path else [],
+                        input_value,
+                        GraphQLError(
+                            f"Field {field_name} of required type {type_str}"
+                            " was not provided."
+                        ),
+                    )
+                continue
+
+            coerced_dict[field.out_name or field_name] = coerce_input_value(
+                field_value, field.type, on_error, Path(path, field_name)
+            )
+
+        # Ensure every provided field is defined.
+        for field_name in input_value:
+            if field_name not in fields:
+                suggestions = suggestion_list(field_name, fields)
+                on_error(
+                    path.as_list() if path else [],
+                    input_value,
+                    GraphQLError(
+                        f"Field '{field_name}' is not defined by type {type_.name}."
+                        + did_you_mean(suggestions)
+                    ),
+                )
+        return type_.out_type(coerced_dict)
+
+    if is_scalar_type(type_):
+        # Scalars determine if a value is valid via `parse_value()`, which can throw to
+        # indicate failure. If it throws, maintain a reference to the original error.
+        type_ = cast(GraphQLScalarType, type_)
+        try:
+            parse_result = type_.parse_value(input_value)
+        except (TypeError, ValueError) as error:
+            on_error(
+                path.as_list() if path else [],
+                input_value,
+                GraphQLError(
+                    f"Expected type {type_.name}. {error}", original_error=error
+                ),
+            )
+            return INVALID
+        if parse_result is INVALID:
+            on_error(
+                path.as_list() if path else [],
+                input_value,
+                GraphQLError(f"Expected type {type_.name}."),
+            )
+        return parse_result
+
+    if is_enum_type(type_):
+        type_ = cast(GraphQLEnumType, type_)
+        values = type_.values
+        if isinstance(input_value, str):
+            enum_value = values.get(input_value)
+            if enum_value:
+                return enum_value.value
+        suggestions = suggestion_list(str(input_value), values)
+        on_error(
+            path.as_list() if path else [],
+            input_value,
+            GraphQLError(f"Expected type {type_.name}." + did_you_mean(suggestions)),
+        )
+        return INVALID
+
+    # Not reachable. All possible input types have been considered.
+    raise TypeError(f"Unexpected input type: '{inspect(type_)}'.")  # pragma: no cover