Preserve input field properties when sorting

Author: Cito

src/graphql/type/validate.py

@@ -589,7 +589,8 @@ def __call__(self, input_obj: GraphQLInputObjectType) -> None:
 
 
 def get_all_implements_interface_nodes(
-    type_: Union[GraphQLObjectType, GraphQLInterfaceType], iface: GraphQLInterfaceType
+    type_: Union[GraphQLObjectType, GraphQLInterfaceType],
+    iface: Union[GraphQLObjectType, GraphQLInterfaceType],
 ) -> List[NamedTypeNode]:
     ast_node = type_.ast_node
     nodes = type_.extension_ast_nodes

src/graphql/utilities/lexicographic_sort_schema.py

@@ -92,13 +92,13 @@ def sort_input_fields(
     ) -> Dict[str, GraphQLInputField]:
         return {
             name: GraphQLInputField(
-                cast(
-                    GraphQLInputType, replace_type(cast(GraphQLNamedType, field.type))
-                ),
-                description=field.description,
-                default_value=field.default_value,
-                extensions=field.extensions,
-                ast_node=field.ast_node,
+                **merge_kwargs(
+                    field.to_kwargs(),
+                    type_=cast(
+                        GraphQLInputType,
+                        replace_type(cast(GraphQLNamedType, field.type)),
+                    ),
+                )
             )
             for name, field in sorted(fields_map.items())
         }

tests/utilities/test_lexicographic_sort_schema.py

@@ -1,4 +1,15 @@
-from graphql.utilities import build_schema, print_schema, lexicographic_sort_schema
+from typing import cast
+
+from graphql.type import (
+    GraphQLArgument,
+    GraphQLField,
+    GraphQLInputField,
+    GraphQLInputObjectType,
+    GraphQLObjectType,
+    GraphQLSchema,
+    GraphQLString,
+)
+from graphql.utilities import build_schema, lexicographic_sort_schema, print_schema
 
 from ..utils import dedent
 
@@ -342,3 +353,102 @@ def sort_recursive_types():
               fooC: FooC
             }
             """)
+
+    def describe_input_field_properties():
+        def preserves_input_field_deprecation_reason():
+            input_type = GraphQLInputObjectType(
+                "TestInput",
+                {
+                    "zField": GraphQLInputField(GraphQLString),
+                    "aField": GraphQLInputField(
+                        GraphQLString, deprecation_reason="Use bField instead"
+                    ),
+                    "mField": GraphQLInputField(
+                        GraphQLString, deprecation_reason="Deprecated field"
+                    ),
+                },
+            )
+            query_type = GraphQLObjectType(
+                "Query",
+                {
+                    "dummy": GraphQLField(
+                        GraphQLString, args={"input": GraphQLArgument(input_type)}
+                    )
+                },
+            )
+            schema = GraphQLSchema(query=query_type, types=[input_type])
+            sorted_schema = lexicographic_sort_schema(schema)
+
+            sorted_input_type = cast(
+                GraphQLInputObjectType, sorted_schema.type_map["TestInput"]
+            )
+            field_names = list(sorted_input_type.fields)
+            assert field_names == ["aField", "mField", "zField"]
+
+            assert (
+                sorted_input_type.fields["aField"].deprecation_reason
+                == "Use bField instead"
+            )
+            assert (
+                sorted_input_type.fields["mField"].deprecation_reason
+                == "Deprecated field"
+            )
+            assert sorted_input_type.fields["zField"].deprecation_reason is None
+
+        def preserves_input_field_extensions():
+            input_type = GraphQLInputObjectType(
+                "TestInput",
+                {
+                    "zField": GraphQLInputField(GraphQLString, extensions={"x": 1}),
+                    "aField": GraphQLInputField(
+                        GraphQLString, extensions={"custom": "value"}
+                    ),
+                },
+            )
+            query_type = GraphQLObjectType(
+                "Query",
+                {
+                    "dummy": GraphQLField(
+                        GraphQLString, args={"input": GraphQLArgument(input_type)}
+                    )
+                },
+            )
+            schema = GraphQLSchema(query=query_type, types=[input_type])
+            sorted_schema = lexicographic_sort_schema(schema)
+            sorted_input_type = cast(
+                GraphQLInputObjectType, sorted_schema.type_map["TestInput"]
+            )
+
+            field_names = list(sorted_input_type.fields)
+            assert field_names == ["aField", "zField"]
+
+            assert sorted_input_type.fields["aField"].extensions == {"custom": "value"}
+            assert sorted_input_type.fields["zField"].extensions == {"x": 1}
+
+        def preserves_input_field_out_name():
+            input_type = GraphQLInputObjectType(
+                "TestInput",
+                {
+                    "zField": GraphQLInputField(GraphQLString, out_name="z_field"),
+                    "aField": GraphQLInputField(GraphQLString, out_name="a_field"),
+                },
+            )
+            query_type = GraphQLObjectType(
+                "Query",
+                {
+                    "dummy": GraphQLField(
+                        GraphQLString, args={"input": GraphQLArgument(input_type)}
+                    )
+                },
+            )
+            schema = GraphQLSchema(query=query_type, types=[input_type])
+            sorted_schema = lexicographic_sort_schema(schema)
+            sorted_input_type = cast(
+                GraphQLInputObjectType, sorted_schema.type_map["TestInput"]
+            )
+
+            field_names = list(sorted_input_type.fields)
+            assert field_names == ["aField", "zField"]
+
+            assert sorted_input_type.fields["aField"].out_name == "a_field"
+            assert sorted_input_type.fields["zField"].out_name == "z_field"