Transform input objects used as default values

Author: Cito

src/graphql/execution/values.py

@@ -23,6 +23,7 @@
     GraphQLField,
     GraphQLInputType,
     GraphQLSchema,
+    is_input_object_type,
     is_input_type,
     is_non_null_type,
 )
@@ -160,8 +161,13 @@ def get_argument_values(
         argument_node = arg_node_map.get(name)
 
         if argument_node is None:
-            if arg_def.default_value is not Undefined:
-                coerced_values[arg_def.out_name or name] = arg_def.default_value
+            value = arg_def.default_value
+            if value is not Undefined:
+                if is_input_object_type(arg_def.type):
+                    # coerce input value so that out_names are used
+                    value = coerce_input_value(value, arg_def.type)
+
+                coerced_values[arg_def.out_name or name] = value
             elif is_non_null_type(arg_type):  # pragma: no cover else
                 raise GraphQLError(
                     f"Argument '{name}' of required type '{arg_type}'"
@@ -176,8 +182,12 @@ def get_argument_values(
         if isinstance(value_node, VariableNode):
             variable_name = value_node.name.value
             if variable_values is None or variable_name not in variable_values:
-                if arg_def.default_value is not Undefined:
-                    coerced_values[arg_def.out_name or name] = arg_def.default_value
+                value = arg_def.default_value
+                if value is not Undefined:
+                    if is_input_object_type(arg_def.type):
+                        # coerce input value so that out_names are used
+                        value = coerce_input_value(value, arg_def.type)
+                    coerced_values[arg_def.out_name or name] = value
                 elif is_non_null_type(arg_type):  # pragma: no cover else
                     raise GraphQLError(
                         f"Argument '{name}' of required type '{arg_type}'"

tests/execution/test_resolve.py

@@ -2,14 +2,16 @@
 from typing import Any
 
 from graphql.error import GraphQLError
-from graphql.execution import execute_sync, ExecutionResult
-from graphql.language import parse, SourceLocation
+from graphql.execution import ExecutionResult, execute_sync
+from graphql.language import SourceLocation, parse
 from graphql.type import (
     GraphQLArgument,
     GraphQLField,
+    GraphQLID,
     GraphQLInputField,
     GraphQLInputObjectType,
     GraphQLInt,
+    GraphQLList,
     GraphQLObjectType,
     GraphQLSchema,
     GraphQLString,
@@ -213,6 +215,91 @@ def execute_query(query: str, root_value: Any = None) -> ExecutionResult:
             None,
         )
 
+    def transforms_default_values_using_out_names():
+        # This is an extension of GraphQL.js.
+        resolver_kwargs: Any
+
+        def search_resolver(_obj: None, _info, **kwargs):
+            nonlocal resolver_kwargs
+            resolver_kwargs = kwargs
+            return [{"id": "42"}]
+
+        filters_type = GraphQLInputObjectType(
+            "SearchFilters",
+            {"pageSize": GraphQLInputField(GraphQLInt, out_name="page_size")},
+        )
+        result_type = GraphQLObjectType("SearchResult", {"id": GraphQLField(GraphQLID)})
+        query = GraphQLObjectType(
+            "Query",
+            {
+                "search": GraphQLField(
+                    GraphQLList(result_type),
+                    {
+                        "searchFilters": GraphQLArgument(
+                            filters_type, {"pageSize": 10}, out_name="search_filters"
+                        )
+                    },
+                    resolve=search_resolver,
+                )
+            },
+        )
+        schema = GraphQLSchema(query)
+
+        resolver_kwargs = None
+        result = execute_sync(schema, parse("{ search { id } }"))
+        assert result == ({"search": [{"id": "42"}]}, None)
+        assert resolver_kwargs == {"search_filters": {"page_size": 10}}
+
+        resolver_kwargs = None
+        result = execute_sync(
+            schema, parse("{ search(searchFilters:{pageSize: 25}) { id } }")
+        )
+        assert result == ({"search": [{"id": "42"}]}, None)
+        assert resolver_kwargs == {"search_filters": {"page_size": 25}}
+
+        resolver_kwargs = None
+        result = execute_sync(
+            schema,
+            parse(
+                """
+                    query ($searchFilters: SearchFilters) {
+                      search(searchFilters: $searchFilters) { id }
+                }
+                """
+            ),
+        )
+        assert result == ({"search": [{"id": "42"}]}, None)
+        assert resolver_kwargs == {"search_filters": {"page_size": 10}}
+
+        resolver_kwargs = None
+        result = execute_sync(
+            schema,
+            parse(
+                """
+                    query ($searchFilters: SearchFilters) {
+                      search(searchFilters: $searchFilters) { id }
+                }
+                """
+            ),
+            variable_values={"searchFilters": {"pageSize": 25}},
+        )
+        assert result == ({"search": [{"id": "42"}]}, None)
+        assert resolver_kwargs == {"search_filters": {"page_size": 25}}
+
+        resolver_kwargs = None
+        result = execute_sync(
+            schema,
+            parse(
+                """
+                    query ($searchFilters: SearchFilters = {pageSize: 25}) {
+                      search(searchFilters: $searchFilters) { id }
+                }
+                """
+            ),
+        )
+        assert result == ({"search": [{"id": "42"}]}, None)
+        assert resolver_kwargs == {"search_filters": {"page_size": 25}}
+
     def pass_error_from_resolver_wrapped_as_located_graphql_error():
         def resolve(_obj, _info):
             raise ValueError("Some error")