feat: sort introspection types alphabetically by name

CHANGELOG.md

···
 # Changelog
 
-## 2.0.1
+## 2.1.0
 
 ### Added
 
 - Argument type validation: list arguments now produce helpful errors when passed objects instead of lists
 - `isOneOf` field in type introspection for INPUT_OBJECT types (GraphQL spec compliance)
+- Introspection types are now returned in alphabetical order by name
 
 ## 2.0.0
 

gleam.toml

···
 name = "swell"
-version = "2.0.1"
+version = "2.1.0"
 description = "🌊 A GraphQL implementation in Gleam"
 licences = ["Apache-2.0"]
 repository = { type = "github", user = "bigmoves", repo = "swell" }

src/swell/introspection.gleam

···
 import gleam/list
 import gleam/option
 import gleam/result
+import gleam/string
 import swell/schema
 import swell/value
 
···
 fn get_all_types(graphql_schema: schema.Schema) -> List(value.Value) {
   let all_types = get_all_schema_types(graphql_schema)
 
-  // Convert all types to introspection values
-  list.map(all_types, type_introspection)
+  // Sort types alphabetically by name, then convert to introspection values
+  all_types
+  |> list.sort(fn(a, b) { string.compare(schema.type_name(a), schema.type_name(b)) })
+  |> list.map(type_introspection)
 }
 
 /// Deduplicate types by name, keeping the version with the most fields

test/introspection_test.gleam

···
 /// Comprehensive tests for introspection queries
 import gleam/list
 import gleam/option.{None}
+import gleam/string
 import gleeunit/should
 import swell/executor
 import swell/schema
···
   }
   |> should.be_true
 }
+
+/// Test: Introspection types are returned in alphabetical order
+/// Verifies that __schema.types are sorted alphabetically by name
+pub fn schema_types_alphabetical_order_test() {
+  let schema = test_schema()
+  let query = "{ __schema { types { name } } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+  |> fn(response) {
+    case response {
+      executor.Response(data: value.Object(fields), errors: []) -> {
+        case list.key_find(fields, "__schema") {
+          Ok(value.Object(schema_fields)) -> {
+            case list.key_find(schema_fields, "types") {
+              Ok(value.List(types)) -> {
+                // Extract type names
+                let names =
+                  list.filter_map(types, fn(type_val) {
+                    case type_val {
+                      value.Object(type_fields) -> {
+                        case list.key_find(type_fields, "name") {
+                          Ok(value.String(name)) -> Ok(name)
+                          _ -> Error(Nil)
+                        }
+                      }
+                      _ -> Error(Nil)
+                    }
+                  })
+
+                // Check that names are sorted alphabetically
+                // Expected order: Boolean, Float, ID, Int, Query, String
+                let sorted_names = list.sort(names, string.compare)
+                names == sorted_names
+              }
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}