Remove excessive cache inside lexicographicSortSchema

Replicates graphql/graphql-js@c2bc19b

Author: Cito

graphql/utilities/lexicographic_sort_schema.py

@@ -1,5 +1,4 @@
-from operator import attrgetter
-from typing import Collection, Dict, List, cast
+from typing import Dict, List, Tuple, cast
 
 from ..type import (
     GraphQLArgument,
@@ -24,7 +23,6 @@
     is_non_null_type,
     is_object_type,
     is_scalar_type,
-    is_specified_scalar_type,
     is_union_type,
 )
 
@@ -34,15 +32,24 @@
 def lexicographic_sort_schema(schema: GraphQLSchema) -> GraphQLSchema:
     """Sort GraphQLSchema."""
 
-    cache: Dict[str, GraphQLNamedType] = {}
+    def replace_type(type_):
+        if is_list_type(type_):
+            return GraphQLList(replace_type(type_.of_type))
+        elif is_non_null_type(type_):
+            return GraphQLNonNull(replace_type(type_.of_type))
+        else:
+            return replace_named_type(type_)
+
+    def replace_named_type(type_: GraphQLNamedType) -> GraphQLNamedType:
+        return type_map[type_.name]
 
-    def sort_maybe_type(maybe_type):
-        return maybe_type and sort_named_type(maybe_type)
+    def replace_maybe_type(maybe_type):
+        return maybe_type and replace_named_type(maybe_type)
 
     def sort_directive(directive):
         kwargs = directive.to_kwargs()
         kwargs.update(
-            locations=sorted(directive.locations, key=attrgetter("name")),
+            locations=sorted(directive.locations, key=sort_by_name_key),
             args=sort_args(directive.args),
         )
         return GraphQLDirective(**kwargs)
@@ -51,58 +58,43 @@ def sort_args(args_map):
         args = {}
         for name, arg in sorted(args_map.items()):
             kwargs = arg.to_kwargs()
-            kwargs.update(type_=sort_type(arg.type))
+            kwargs.update(type_=replace_type(arg.type))
             args[name] = GraphQLArgument(**kwargs)
         return args
 
     def sort_fields(fields_map):
         fields = {}
         for name, field in sorted(fields_map.items()):
             kwargs = field.to_kwargs()
-            kwargs.update(type_=sort_type(field.type), args=sort_args(field.args))
+            kwargs.update(type_=replace_type(field.type), args=sort_args(field.args))
             fields[name] = GraphQLField(**kwargs)
         return fields
 
     def sort_input_fields(fields_map):
         return {
             name: GraphQLInputField(
-                sort_type(field.type),
+                replace_type(field.type),
                 description=field.description,
                 default_value=field.default_value,
                 ast_node=field.ast_node,
             )
             for name, field in sorted(fields_map.items())
         }
 
-    def sort_type(type_):
-        if is_list_type(type_):
-            return GraphQLList(sort_type(type_.of_type))
-        elif is_non_null_type(type_):
-            return GraphQLNonNull(sort_type(type_.of_type))
-        else:
-            return sort_named_type(type_)
+    def sort_types(arr: List[GraphQLNamedType]) -> List[GraphQLNamedType]:
+        return [
+            replace_named_type(type_) for type_ in sorted(arr, key=sort_by_name_key)
+        ]
 
     def sort_named_type(type_: GraphQLNamedType) -> GraphQLNamedType:
-        if is_specified_scalar_type(type_) or is_introspection_type(type_):
-            return type_
-
-        sorted_type = cache.get(type_.name)
-        if not sorted_type:
-            sorted_type = sort_named_type_impl(type_)
-            cache[type_.name] = sorted_type
-        return sorted_type
-
-    def sort_types(arr: Collection[GraphQLNamedType]) -> List[GraphQLNamedType]:
-        return [sort_named_type(type_) for type_ in sorted(arr, key=attrgetter("name"))]
-
-    def sort_named_type_impl(type_: GraphQLNamedType) -> GraphQLNamedType:
-        if is_scalar_type(type_):
+        if is_scalar_type(type_) or is_introspection_type(type_):
             return type_
         elif is_object_type(type_):
             kwargs = type_.to_kwargs()
             object_type = cast(GraphQLObjectType, type_)
+            # noinspection PyTypeChecker
             kwargs.update(
-                interfaces=lambda: sort_types(object_type.interfaces),
+                interfaces=lambda: sort_types(object_type.interfaces),  # type: ignore
                 fields=lambda: sort_fields(object_type.fields),
             )
             return GraphQLObjectType(**kwargs)
@@ -114,7 +106,8 @@ def sort_named_type_impl(type_: GraphQLNamedType) -> GraphQLNamedType:
         elif is_union_type(type_):
             kwargs = type_.to_kwargs()
             union_type = cast(GraphQLUnionType, type_)
-            kwargs.update(types=lambda: sort_types(union_type.types))
+            # noinspection PyTypeChecker
+            kwargs.update(types=lambda: sort_types(union_type.types))  # type: ignore
             return GraphQLUnionType(**kwargs)
         elif is_enum_type(type_):
             kwargs = type_.to_kwargs()
@@ -134,18 +127,29 @@ def sort_named_type_impl(type_: GraphQLNamedType) -> GraphQLNamedType:
         elif is_input_object_type(type_):
             kwargs = type_.to_kwargs()
             input_object_type = cast(GraphQLInputObjectType, type_)
-            kwargs.update(fields=sort_input_fields(input_object_type.fields))
+            kwargs.update(fields=lambda: sort_input_fields(input_object_type.fields))
             return GraphQLInputObjectType(**kwargs)
         raise TypeError(f"Unknown type: '{type_}'")
 
+    type_map: Dict[str, GraphQLNamedType] = {
+        type_.name: sort_named_type(type_)
+        for type_ in sorted(schema.type_map.values(), key=sort_by_name_key)
+    }
+
     return GraphQLSchema(
-        types=sort_types(schema.type_map.values()),
+        types=list(type_map.values()),
         directives=[
             sort_directive(directive)
-            for directive in sorted(schema.directives, key=attrgetter("name"))
+            for directive in sorted(schema.directives, key=sort_by_name_key)
         ],
-        query=sort_maybe_type(schema.query_type),
-        mutation=sort_maybe_type(schema.mutation_type),
-        subscription=sort_maybe_type(schema.subscription_type),
+        query=replace_maybe_type(schema.query_type),
+        mutation=replace_maybe_type(schema.mutation_type),
+        subscription=replace_maybe_type(schema.subscription_type),
         ast_node=schema.ast_node,
     )
+
+
+def sort_by_name_key(type_) -> Tuple[bool, str]:
+    name = type_.name
+    # GraphQL.JS sorts '_' first using localeCompare
+    return not name.startswith("_"), name