fix(executor): use canonical type registry for union resolution

- Add type registry to ensure union types resolve to complete type definitions
- Make build_type_map public in introspection module
- Add get_union_type_resolver and resolve_union_type_with_registry functions
- Add test for union resolution with all fields via registry
- Bump version to 2.1.2

CHANGELOG.md

···
 # Changelog
 
+## 2.1.2
+
+### Fixed
+
+- Union type resolution now uses a canonical type registry, ensuring resolved types have complete field definitions
+- Made `build_type_map` public in introspection module for building type registries
+- Added `get_union_type_resolver` to extract the type resolver function from union types
+- Added `resolve_union_type_with_registry` for registry-based union resolution
+
 ## 2.1.1
 
 ### Fixed

gleam.toml

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

src/swell/executor.gleam

···
     Error(parse_error) ->
       Error("Parse error: " <> format_parse_error(parse_error))
     Ok(document) -> {
+      // Build canonical type registry for union resolution
+      // This ensures we use the most complete version of each type
+      let type_registry = build_type_registry(graphql_schema)
+
       // Execute the document
-      case execute_document(document, graphql_schema, ctx) {
+      case execute_document(document, graphql_schema, ctx, type_registry) {
         Ok(#(data, errors)) -> Ok(Response(data, errors))
         Error(err) -> Error(err)
       }
···
   }
 }
 
+/// Build a canonical type registry from the schema
+/// Uses introspection's logic to get deduplicated types with most fields
+fn build_type_registry(
+  graphql_schema: schema.Schema,
+) -> Dict(String, schema.Type) {
+  let all_types = introspection.get_all_schema_types(graphql_schema)
+  introspection.build_type_map(all_types)
+}
+
 fn format_parse_error(err: parser.ParseError) -> String {
   case err {
     parser.UnexpectedToken(_, msg) -> msg
···
   document: parser.Document,
   graphql_schema: schema.Schema,
   ctx: schema.Context,
+  type_registry: Dict(String, schema.Type),
 ) -> Result(#(value.Value, List(GraphQLError)), String) {
   case document {
     parser.Document(operations) -> {
···
       // Execute the first executable operation
       case executable_ops {
         [operation, ..] ->
-          execute_operation(operation, graphql_schema, ctx, fragments_dict)
+          execute_operation(
+            operation,
+            graphql_schema,
+            ctx,
+            fragments_dict,
+            type_registry,
+          )
         [] -> Error("No executable operations in document")
       }
     }
···
   graphql_schema: schema.Schema,
   ctx: schema.Context,
   fragments: Dict(String, parser.Operation),
+  type_registry: Dict(String, schema.Type),
 ) -> Result(#(value.Value, List(GraphQLError)), String) {
   case operation {
     parser.Query(selection_set) -> {
···
         ctx,
         fragments,
         [],
+        type_registry,
       )
     }
     parser.NamedQuery(_name, variables, selection_set) -> {
···
         ctx_with_defaults,
         fragments,
         [],
+        type_registry,
       )
     }
     parser.Mutation(selection_set) -> {
···
             ctx,
             fragments,
             [],
+            type_registry,
           )
         option.None -> Error("Schema does not define a mutation type")
       }
···
             ctx_with_defaults,
             fragments,
             [],
+            type_registry,
           )
         }
         option.None -> Error("Schema does not define a mutation type")
···
             ctx,
             fragments,
             [],
+            type_registry,
           )
         option.None -> Error("Schema does not define a subscription type")
       }
···
             ctx_with_defaults,
             fragments,
             [],
+            type_registry,
           )
         }
         option.None -> Error("Schema does not define a subscription type")
···
   ctx: schema.Context,
   fragments: Dict(String, parser.Operation),
   path: List(String),
+  type_registry: Dict(String, schema.Type),
 ) -> Result(#(value.Value, List(GraphQLError)), String) {
   case selection_set {
     parser.SelectionSet(selections) -> {
···
             ctx,
             fragments,
             path,
+            type_registry,
           )
         })
 
···
   ctx: schema.Context,
   fragments: Dict(String, parser.Operation),
   path: List(String),
+  type_registry: Dict(String, schema.Type),
 ) -> Result(#(String, value.Value, List(GraphQLError)), String) {
   case selection {
     parser.FragmentSpread(name) -> {
···
                   ctx,
                   fragments,
                   path,
+                  type_registry,
                 )
               {
                 Ok(#(value.Object(fields), errs)) -> {
···
               ctx,
               fragments,
               path,
+              type_registry,
             )
           {
             Ok(#(value.Object(fields), errs)) ->
···
                           case field_value {
                             value.Object(_) -> {
                               // Check if field_type_def is a union type
-                              // If so, resolve it to the concrete type first
+                              // If so, resolve it to the concrete type first using the registry
                               let type_to_use = case
                                 schema.is_union(field_type_def)
                               {
···
                                   let resolve_ctx =
                                     schema.context(option.Some(field_value))
                                   case
-                                    schema.resolve_union_type(
+                                    schema.resolve_union_type_with_registry(
                                       field_type_def,
                                       resolve_ctx,
+                                      type_registry,
                                     )
                                   {
                                     Ok(concrete_type) -> concrete_type
···
                                   object_ctx,
                                   fragments,
                                   [name, ..path],
+                                  type_registry,
                                 )
                               {
                                 Ok(#(nested_data, nested_errors)) ->
···
                                 parser.SelectionSet(nested_selections)
                               let results =
                                 list.map(items, fn(item) {
-                                  // Check if inner_type is a union and resolve it
+                                  // Check if inner_type is a union and resolve it using the registry
                                   // Need to unwrap NonNull to check for union since inner_type
                                   // could be NonNull[Union] after unwrapping List[NonNull[Union]]
                                   let unwrapped_inner = case
···
                                       let resolve_ctx =
                                         schema.context(option.Some(item))
                                       case
-                                        schema.resolve_union_type(
+                                        schema.resolve_union_type_with_registry(
                                           unwrapped_inner,
                                           resolve_ctx,
+                                          type_registry,
                                         )
                                       {
                                         Ok(concrete_type) -> concrete_type
···
                                     item_ctx,
                                     fragments,
                                     [name, ..path],
+                                    type_registry,
                                   )
                                 })
 

src/swell/introspection.gleam

···
       !list.contains(collected_names, built_in_name)
     })
 
-  list.append(unique_types, missing_built_ins)
+  let all_types = list.append(unique_types, missing_built_ins)
+
+  // Build a canonical type map for normalization
+  let type_map = build_type_map(all_types)
+
+  // Normalize union types so their possible_types reference canonical instances
+  list.map(all_types, fn(t) { normalize_union_possible_types(t, type_map) })
+}
+
+/// Build a map from type name to canonical type instance
+/// This creates a registry that can be used to look up types by name,
+/// ensuring consistent type references throughout the system.
+pub fn build_type_map(
+  types: List(schema.Type),
+) -> dict.Dict(String, schema.Type) {
+  list.fold(types, dict.new(), fn(acc, t) {
+    dict.insert(acc, schema.type_name(t), t)
+  })
+}
+
+/// For union types, replace possible_types with canonical instances from the type map
+/// This ensures union.possible_types returns the same instances as found elsewhere
+fn normalize_union_possible_types(
+  t: schema.Type,
+  type_map: dict.Dict(String, schema.Type),
+) -> schema.Type {
+  case schema.is_union(t) {
+    True -> {
+      let original_possible = schema.get_possible_types(t)
+      let normalized_possible =
+        list.filter_map(original_possible, fn(pt) {
+          dict.get(type_map, schema.type_name(pt))
+        })
+      schema.union_type(
+        schema.type_name(t),
+        schema.type_description(t),
+        normalized_possible,
+        schema.get_union_type_resolver(t),
+      )
+    }
+    False -> t
+  }
 }
 
 /// Get all types from the schema

src/swell/schema.gleam

···
   }
 }
 
+/// Get the type resolver function from a union type.
+/// The type resolver is called at runtime to determine which concrete type
+/// a union value represents, based on the data in the context.
+/// Returns a default resolver that always errors for non-union types.
+/// This is primarily used internally for union type normalization.
+pub fn get_union_type_resolver(t: Type) -> fn(Context) -> Result(String, String) {
+  case t {
+    UnionType(_, _, _, type_resolver) -> type_resolver
+    _ -> fn(_) { Error("Not a union type") }
+  }
+}
+
 /// Resolve a union type to its concrete type using the type resolver
 pub fn resolve_union_type(t: Type, ctx: Context) -> Result(Type, String) {
   case t {
···
                 "Type resolver returned '"
                 <> resolved_type_name
                 <> "' which is not a possible type of this union",
+              )
+          }
+        }
+        Error(err) -> Error(err)
+      }
+    }
+    _ -> Error("Cannot resolve non-union type")
+  }
+}
+
+/// Resolve a union type using a canonical type registry
+/// This looks up the concrete type by name from the registry instead of from
+/// the union's possible_types, ensuring we get the most complete type definition
+pub fn resolve_union_type_with_registry(
+  t: Type,
+  ctx: Context,
+  type_registry: dict.Dict(String, Type),
+) -> Result(Type, String) {
+  case t {
+    UnionType(_, _, _, type_resolver) -> {
+      // Call the type resolver to get the concrete type name
+      case type_resolver(ctx) {
+        Ok(resolved_type_name) -> {
+          // Look up the type from the canonical registry
+          case dict.get(type_registry, resolved_type_name) {
+            Ok(concrete_type) -> Ok(concrete_type)
+            Error(_) ->
+              Error(
+                "Type resolver returned '"
+                <> resolved_type_name
+                <> "' which is not in the type registry. "
+                <> "This may indicate the schema is incomplete or the type resolver is misconfigured.",
               )
           }
         }

test/executor_test.gleam

···
     _ -> should.fail()
   }
 }
+
+// Test: Union resolution uses canonical type registry
+// This verifies that when resolving a union type, all fields from the
+// canonical type definition are accessible, not just those from the
+// union's internal possible_types copy
+pub fn execute_union_with_all_fields_via_registry_test() {
+  // Create a type with multiple fields to verify complete resolution
+  let article_type =
+    schema.object_type("Article", "An article", [
+      schema.field("id", schema.id_type(), "Article ID", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "id") {
+              Ok(id_val) -> Ok(id_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("title", schema.string_type(), "Article title", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "title") {
+              Ok(title_val) -> Ok(title_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("body", schema.string_type(), "Article body", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "body") {
+              Ok(body_val) -> Ok(body_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("author", schema.string_type(), "Article author", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "author") {
+              Ok(author_val) -> Ok(author_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+    ])
+
+  let video_type =
+    schema.object_type("Video", "A video", [
+      schema.field("id", schema.id_type(), "Video ID", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "id") {
+              Ok(id_val) -> Ok(id_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("title", schema.string_type(), "Video title", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "title") {
+              Ok(title_val) -> Ok(title_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("duration", schema.int_type(), "Video duration", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "duration") {
+              Ok(duration_val) -> Ok(duration_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+    ])
+
+  // Type resolver that examines the __typename field
+  let type_resolver = fn(ctx: schema.Context) -> Result(String, String) {
+    case ctx.data {
+      option.Some(value.Object(fields)) -> {
+        case list.key_find(fields, "__typename") {
+          Ok(value.String(type_name)) -> Ok(type_name)
+          _ -> Error("No __typename field found")
+        }
+      }
+      _ -> Error("No data")
+    }
+  }
+
+  // Create union type
+  let content_union =
+    schema.union_type(
+      "Content",
+      "Content union",
+      [article_type, video_type],
+      type_resolver,
+    )
+
+  // Create query type with a field returning the union
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field("content", content_union, "Get content", fn(_ctx) {
+        // Return an Article with all fields populated
+        Ok(
+          value.Object([
+            #("__typename", value.String("Article")),
+            #("id", value.String("article-1")),
+            #("title", value.String("GraphQL Best Practices")),
+            #("body", value.String("Here are some tips...")),
+            #("author", value.String("Jane Doe")),
+          ]),
+        )
+      }),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+
+  // Query requesting ALL fields from the Article type
+  // If the type registry works correctly, all 4 fields should be returned
+  let query =
+    "
+    {
+      content {
+        ... on Article {
+          id
+          title
+          body
+          author
+        }
+        ... on Video {
+          id
+          title
+          duration
+        }
+      }
+    }
+    "
+
+  let result = executor.execute(query, test_schema, schema.context(None))
+
+  case result {
+    Ok(executor.Response(value.Object(fields), errors)) -> {
+      // Should have no errors
+      list.length(errors)
+      |> should.equal(0)
+
+      // Check the content field
+      case list.key_find(fields, "content") {
+        Ok(value.Object(content_fields)) -> {
+          // Should have all 4 Article fields
+          list.length(content_fields)
+          |> should.equal(4)
+
+          // Verify each field is present with correct value
+          case list.key_find(content_fields, "id") {
+            Ok(value.String("article-1")) -> should.be_true(True)
+            _ -> should.fail()
+          }
+          case list.key_find(content_fields, "title") {
+            Ok(value.String("GraphQL Best Practices")) -> should.be_true(True)
+            _ -> should.fail()
+          }
+          case list.key_find(content_fields, "body") {
+            Ok(value.String("Here are some tips...")) -> should.be_true(True)
+            _ -> should.fail()
+          }
+          case list.key_find(content_fields, "author") {
+            Ok(value.String("Jane Doe")) -> should.be_true(True)
+            _ -> should.fail()
+          }
+        }
+        _ -> should.fail()
+      }
+    }
+    Error(err) -> {
+      // Print error for debugging
+      should.equal(err, "")
+    }
+    _ -> should.fail()
+  }
+}