feat: add lexicographic_sort_schema config option

RELEASE.md

@@ -0,0 +1,19 @@
+Release type: minor
+
+Add a new `lexicographic_sort_schema` option to `StrawberryConfig`. When enabled,
+the schema's types, fields and arguments are sorted alphabetically, affecting both
+the introspection result and the exported SDL. This makes it easier to find
+related fields (for example `userById`, `userByName`) in the GraphiQL UI and in
+exported `schema.graphql` files.
+
+```python
+import strawberry
+from strawberry.schema.config import StrawberryConfig
+
+schema = strawberry.Schema(
+    query=Query,
+    config=StrawberryConfig(lexicographic_sort_schema=True),
+)
+```
+
+It defaults to `False`, preserving the existing definition order.

docs/types/schema-configurations.md

@@ -106,6 +106,43 @@ schema = strawberry.Schema(
 )
 ```
 
+### lexicographic_sort_schema
+
+By default Strawberry preserves the order in which fields and types are defined.
+This can make the introspection UI and the exported `schema.graphql` file harder
+to read, since related fields (for example `userById`, `userByName`) are not
+grouped together.
+
+Setting `lexicographic_sort_schema` to `True` sorts all types, fields and
+arguments alphabetically, affecting both the introspection result and the
+exported SDL.
+
+```python
+schema = strawberry.Schema(
+    query=Query, config=StrawberryConfig(lexicographic_sort_schema=True)
+)
+```
+
+With sorting enabled a schema like:
+
+```graphql
+type Query {
+  userByName(name: String!): User!
+  allUsers: [User!]!
+  userById(id: Int!): User!
+}
+```
+
+becomes:
+
+```graphql
+type Query {
+  allUsers: [User!]!
+  userById(id: Int!): User!
+  userByName(name: String!): User!
+}
+```
+
 ### info_class
 
 By default Strawberry will create an object of type `strawberry.Info` when the

strawberry/schema/config.py

@@ -34,6 +34,10 @@ class StrawberryConfig:
             any type (including NewType) to be used as a GraphQL scalar with
             proper type checking support.
         batching_config: Configuration for operation batching.
+        lexicographic_sort_schema: Whether to sort the schema's types, fields and
+            arguments lexicographically. This affects both the introspection
+            result and the exported SDL, making it easier to find related
+            fields. Defaults to False, which preserves definition order.
     """
 
     auto_camel_case: InitVar[bool] = None  # pyright: reportGeneralTypeIssues=false
@@ -47,6 +51,7 @@ class StrawberryConfig:
     _unsafe_disable_same_type_validation: bool = False
     scalar_map: Mapping[object, ScalarDefinition] = field(default_factory=dict)
     batching_config: BatchingConfig | None = None
+    lexicographic_sort_schema: bool = False
 
     def __post_init__(
         self,

strawberry/schema/schema.py

@@ -29,6 +29,7 @@
     GraphQLSchema,
     OperationDefinitionNode,
     get_introspection_query,
+    lexicographic_sort_schema,
     parse,
     validate_schema,
 )
@@ -371,6 +372,9 @@ class Query:
 
             raise
 
+        if self.config.lexicographic_sort_schema:
+            self._schema = lexicographic_sort_schema(self._schema)
+
         # attach our schema to the GraphQL schema instance
         self._schema._strawberry_schema = self  # type: ignore
 

tests/schema/test_config.py

@@ -1,5 +1,8 @@
+import textwrap
+
 import pytest
 
+import strawberry
 from strawberry.schema.config import StrawberryConfig
 from strawberry.types.info import Info
 
@@ -37,3 +40,82 @@ def test_config_post_init_info_class_is_not_subclass():
         StrawberryConfig(info_class=object)
 
     assert str(exc_info.value) == "`info_class` must be a subclass of strawberry.Info"
+
+
+def test_lexicographic_sort_schema_defaults_to_false():
+    assert StrawberryConfig().lexicographic_sort_schema is False
+
+
+def test_lexicographic_sort_schema_preserves_definition_order_by_default():
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def zebra(self) -> int: ...
+
+        @strawberry.field
+        def apple(self) -> int: ...
+
+    schema = strawberry.Schema(query=Query)
+
+    expected = """\
+    type Query {
+      zebra: Int!
+      apple: Int!
+    }"""
+
+    assert str(schema) == textwrap.dedent(expected).strip()
+
+
+def test_lexicographic_sort_schema_sorts_fields_and_types():
+    @strawberry.type
+    class User:
+        name: str
+        age: int
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def user_by_name(self, name: str) -> User: ...
+
+        @strawberry.field
+        def all_users(self) -> list[User]: ...
+
+        @strawberry.field
+        def user_by_id(self, id: int) -> User: ...
+
+    schema = strawberry.Schema(
+        query=Query,
+        config=StrawberryConfig(lexicographic_sort_schema=True),
+    )
+
+    expected = """\
+    type Query {
+      allUsers: [User!]!
+      userById(id: Int!): User!
+      userByName(name: String!): User!
+    }
+
+    type User {
+      age: Int!
+      name: String!
+    }"""
+
+    assert str(schema) == textwrap.dedent(expected).strip()
+
+
+def test_lexicographic_sort_schema_still_executes():
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def hello(self, name: str) -> str:
+            return f"Hi {name}"
+
+    schema = strawberry.Schema(
+        query=Query,
+        config=StrawberryConfig(lexicographic_sort_schema=True),
+    )
+
+    result = schema.execute_sync('{ hello(name: "Patrick") }')
+
+    assert not result.errors
+    assert result.data == {"hello": "Hi Patrick"}