Fixed the bug where a nested GraphQLInputObjectType causing infinite recursive calls to get_arg_serializer.

Author: xzhang2

gql/dsl.py

@@ -1,5 +1,6 @@
 from collections.abc import Iterable
 from functools import partial
+from typing import Any, Callable, Dict
 
 from graphql import (
     ArgumentNode,
@@ -105,7 +106,7 @@ def args(self, **kwargs):
             arg = self.field.args.get(name)
             if not arg:
                 raise KeyError(f"Argument {name} does not exist in {self.field}.")
-            arg_type_serializer = get_arg_serializer(arg.type)
+            arg_type_serializer = get_arg_serializer(arg.type, known_serializers=dict())
             serialized_value = arg_type_serializer(value)
             added_args.append(
                 ArgumentNode(name=NameNode(value=name), value=serialized_value)
@@ -151,21 +152,25 @@ def serialize_list(serializer, list_values):
     return ListValueNode(values=FrozenList(serializer(v) for v in list_values))
 
 
-def get_arg_serializer(arg_type):
+def get_arg_serializer(arg_type, known_serializers):
     if isinstance(arg_type, GraphQLNonNull):
-        return get_arg_serializer(arg_type.of_type)
+        return get_arg_serializer(arg_type.of_type, known_serializers)
     if isinstance(arg_type, GraphQLInputField):
-        return get_arg_serializer(arg_type.type)
+        return get_arg_serializer(arg_type.type, known_serializers)
     if isinstance(arg_type, GraphQLInputObjectType):
-        serializers = {k: get_arg_serializer(v) for k, v in arg_type.fields.items()}
-        return lambda value: ObjectValueNode(
+        if arg_type in known_serializers:
+            return known_serializers[arg_type]
+        known_serializers[arg_type] = None
+        serializers = {k: get_arg_serializer(v, known_serializers) for k, v in arg_type.fields.items()}
+        known_serializers[arg_type] = lambda value: ObjectValueNode(
             fields=FrozenList(
                 ObjectFieldNode(name=NameNode(value=k), value=serializers[k](v))
                 for k, v in value.items()
             )
         )
+        return known_serializers[arg_type]
     if isinstance(arg_type, GraphQLList):
-        inner_serializer = get_arg_serializer(arg_type.of_type)
+        inner_serializer = get_arg_serializer(arg_type.of_type, known_serializers)
         return partial(serialize_list, inner_serializer)
     if isinstance(arg_type, GraphQLEnumType):
         return lambda value: EnumValueNode(value=arg_type.serialize(value))

tests/nested_input/__init__.py

@@ -0,0 +1,30 @@
+from graphql import (
+    GraphQLArgument,
+    GraphQLField,
+    GraphQLInputField,
+    GraphQLInputObjectType,
+    GraphQLInt,
+    GraphQLObjectType,
+    GraphQLSchema,
+)
+
+nestedInput = GraphQLInputObjectType(
+    "Nested",
+    description="The input object that has a field pointing to itself",
+    fields={"foo": GraphQLInputField(GraphQLInt, description="foo")},
+)
+
+nestedInput.fields["child"] = GraphQLInputField(nestedInput, description="child")
+
+queryType = GraphQLObjectType(
+    "Query",
+    fields=lambda: {
+        "foo": GraphQLField(
+            args={"nested": GraphQLArgument(type_=nestedInput)},
+            resolve=lambda *args, **kwargs: 1,
+            type_=GraphQLInt,
+        ),
+    },
+)
+
+NestedInputSchema = GraphQLSchema(query=queryType, types=[nestedInput],)

tests/nested_input/schema.py

@@ -0,0 +1,63 @@
+from functools import partial
+
+import pytest
+from graphql import (
+    EnumValueNode,
+    GraphQLEnumType,
+    GraphQLInputField,
+    GraphQLInputObjectType,
+    GraphQLList,
+    GraphQLNonNull,
+    NameNode,
+    ObjectFieldNode,
+    ObjectValueNode,
+    ast_from_value,
+)
+from graphql.pyutils import FrozenList
+
+import gql.dsl as dsl
+from gql import Client
+from gql.dsl import DSLSchema, serialize_list
+from tests.nested_input.schema import NestedInputSchema
+
+# back up the new func
+new_get_arg_serializer = dsl.get_arg_serializer
+
+
+def old_get_arg_serializer(arg_type, known_serializers=None):
+    if isinstance(arg_type, GraphQLNonNull):
+        return old_get_arg_serializer(arg_type.of_type)
+    if isinstance(arg_type, GraphQLInputField):
+        return old_get_arg_serializer(arg_type.type)
+    if isinstance(arg_type, GraphQLInputObjectType):
+        serializers = {k: old_get_arg_serializer(v) for k, v in arg_type.fields.items()}
+        return lambda value: ObjectValueNode(
+            fields=FrozenList(
+                ObjectFieldNode(name=NameNode(value=k), value=serializers[k](v))
+                for k, v in value.items()
+            )
+        )
+    if isinstance(arg_type, GraphQLList):
+        inner_serializer = old_get_arg_serializer(arg_type.of_type)
+        return partial(serialize_list, inner_serializer)
+    if isinstance(arg_type, GraphQLEnumType):
+        return lambda value: EnumValueNode(value=arg_type.serialize(value))
+    return lambda value: ast_from_value(arg_type.serialize(value), arg_type)
+
+
+@pytest.fixture
+def ds():
+    client = Client(schema=NestedInputSchema)
+    ds = DSLSchema(client)
+    return ds
+
+
+def test_nested_input_with_old_get_arg_serializer(ds):
+    dsl.get_arg_serializer = old_get_arg_serializer
+    with pytest.raises(RecursionError, match="maximum recursion depth exceeded"):
+        ds.query(ds.Query.foo.args(nested={"foo": 1}))
+
+
+def test_nested_input_with_new_get_arg_serializer(ds):
+    dsl.get_arg_serializer = new_get_arg_serializer
+    assert ds.query(ds.Query.foo.args(nested={"foo": 1})) == {"foo": 1}