fix: fragment spread and __typename handling for wrapped types

- Add named_type_name function to get base type without List/NonNull wrappers
- Fix fragment spread type condition matching on NonNull/List wrapped types
- Fix inline fragment type condition matching with wrapped types
- Fix __typename to return concrete type name without modifiers

CHANGELOG.md

···
 - Support for variable default values (`$name: Type = defaultValue`)
 - Default values are applied during execution when variables are not provided
 - Provided variables override default values
+- New `schema.named_type_name` function to get the base type name without List/NonNull wrappers
+
+### Fixed
+
+- Fragment spread type condition matching now works correctly when parent type is wrapped in NonNull or List
+- Inline fragment type condition matching now works correctly with wrapped types
+- `__typename` introspection now returns the concrete type name without modifiers
 
 ### Breaking Changes
 

birdie_snapshots/execute_fragment_spread_on_non_null_type.accepted

···
+---
+version: 1.4.1
+title: Execute fragment spread on NonNull type
+file: ./test/executor_test.gleam
+test_name: execute_fragment_spread_on_non_null_type_test
+---
+Response(Object([#("user", Object([#("id", String("123")), #("name", String("Alice"))]))]), [])

src/swell/executor.gleam

···
           type_condition,
           fragment_selection_set,
         )) -> {
-          // Check type condition
-          let current_type_name = schema.type_name(parent_type)
+          // Check type condition - use named_type_name to get the base type
+          // without NonNull/List wrappers, since fragments are defined on named types
+          let current_type_name = schema.named_type_name(parent_type)
           case type_condition == current_type_name {
             False -> {
               // Type condition doesn't match, skip this fragment
···
       }
     }
     parser.InlineFragment(type_condition_opt, inline_selections) -> {
-      // Check type condition if present
-      let current_type_name = schema.type_name(parent_type)
+      // Check type condition if present - use named_type_name to get the base type
+      // without NonNull/List wrappers, since fragments are defined on named types
+      let current_type_name = schema.named_type_name(parent_type)
       let should_execute = case type_condition_opt {
         None -> True
         Some(type_condition) -> type_condition == current_type_name
···
       // Handle introspection meta-fields
       case name {
         "__typename" -> {
-          let type_name = schema.type_name(parent_type)
+          // Use named_type_name to return the concrete type without modifiers
+          let type_name = schema.named_type_name(parent_type)
           Ok(#(key, value.String(type_name), []))
         }
         "__schema" -> {

src/swell/schema.gleam

···
   }
 }
 
+/// Get the named (base) type name, unwrapping List and NonNull wrappers.
+/// This is used for fragment type condition matching and __typename where
+/// we need the concrete type name without modifiers.
+pub fn named_type_name(t: Type) -> String {
+  case t {
+    ScalarType(name) -> name
+    ObjectType(name, _, _) -> name
+    InputObjectType(name, _, _) -> name
+    EnumType(name, _, _) -> name
+    UnionType(name, _, _, _) -> name
+    ListType(inner) -> named_type_name(inner)
+    NonNullType(inner) -> named_type_name(inner)
+  }
+}
+
 pub fn field_name(f: Field) -> String {
   case f {
     Field(name, _, _, _, _) -> name

test/executor_test.gleam

···
   )
 }
 
+// Test for fragment spread on NonNull wrapped type
+pub fn execute_fragment_spread_on_non_null_type_test() {
+  // Create a schema where the user field returns a NonNull type
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(_ctx) {
+        Ok(value.String("123"))
+      }),
+      schema.field("name", schema.string_type(), "User name", fn(_ctx) {
+        Ok(value.String("Alice"))
+      }),
+    ])
+
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      // Wrap user_type in NonNull to test fragment type condition matching
+      schema.field("user", schema.non_null(user_type), "Get user", fn(_ctx) {
+        Ok(
+          value.Object([
+            #("id", value.String("123")),
+            #("name", value.String("Alice")),
+          ]),
+        )
+      }),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+
+  // Fragment is defined on "User" (not "User!") - this should still work
+  let query =
+    "
+    fragment UserFields on User {
+      id
+      name
+    }
+
+    { user { ...UserFields } }
+    "
+
+  let result = executor.execute(query, test_schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute fragment spread on NonNull type",
+    content: format_response(response),
+  )
+}
+
 // Test for list fields with nested selections
 pub fn execute_list_with_nested_selections_test() {
   // Create a schema with a list field