init

.github/workflows/test.yml

···
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "28"
+          gleam-version: "1.13.0"
+          rebar3-version: "3"
+          # elixir-version: "1"
+      - run: gleam deps download
+      - run: gleam test
+      - run: gleam format --check src test

.gitignore

···
+*.beam
+*.ez
+build/
+erl_crash.dump

README.md

···
+# Swell
+
+A GraphQL implementation in Gleam providing query parsing, execution, and introspection support.
+
+![Swell](https://images.unsplash.com/photo-1616645728806-838c6bf184af?ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&q=80&w=2340)
+
+## Features
+
+- Query parsing and execution
+- Mutations with input types
+- Subscriptions for real-time updates
+- Introspection support
+- Type-safe schema builder
+- Fragment support (inline and named)
+
+## Quick Start
+
+Check out the `/example` directory for an example with SQLite.
+
+## Usage
+
+```gleam
+import swell/schema
+import swell/executor
+import swell/value
+
+// Define your schema
+let user_type = schema.object_type("User", "A user", [
+  schema.field("id", schema.id_type(), "User ID", fn(ctx) {
+    case ctx.data {
+      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("name", schema.string_type(), "User name", fn(ctx) {
+    case ctx.data {
+      Some(value.Object(fields)) -> {
+        case list.key_find(fields, "name") {
+          Ok(name_val) -> Ok(name_val)
+          Error(_) -> Ok(value.Null)
+        }
+      }
+      _ -> Ok(value.Null)
+    }
+  }),
+])
+
+let query_type = schema.object_type("Query", "Root query", [
+  schema.field("user", user_type, "Get a user", fn(_ctx) {
+    Ok(value.Object([
+      #("id", value.String("1")),
+      #("name", value.String("Alice")),
+    ]))
+  }),
+])
+
+let my_schema = schema.schema(query_type, None)
+
+// Execute a query
+let result = executor.execute("{ user { id name } }", my_schema, schema.context(None))
+```
+
+## Known Limitations
+
+- Directives not implemented (`@skip`, `@include`, custom directives)
+- Interface types not implemented
+- Custom scalar serialization/deserialization (can define custom scalar types but no validation or coercion beyond built-in types)
+
+## Development
+
+```sh
+gleam test  # Run tests
+gleam build # Build the package
+```

birdie_snapshots/built_in_scalar_types.accepted

···
+---
+version: 1.4.1
+title: Built-in scalar types
+file: ./test/sdl_test.gleam
+test_name: built_in_scalars_test
+---
+scalar String
+
+scalar Int
+
+scalar Float
+
+scalar Boolean
+
+scalar ID

birdie_snapshots/empty_enum.accepted

···
+---
+version: 1.4.1
+title: Empty enum
+file: ./test/sdl_test.gleam
+test_name: empty_enum_test
+---
+"""An empty enum"""
+enum EmptyEnum {}

birdie_snapshots/empty_input_object.accepted

···
+---
+version: 1.4.1
+title: Empty input object
+file: ./test/sdl_test.gleam
+test_name: empty_input_object_test
+---
+"""An empty input"""
+input EmptyInput {}

birdie_snapshots/enum_without_descriptions.accepted

···
+---
+version: 1.4.1
+title: Enum without descriptions
+file: ./test/sdl_test.gleam
+test_name: enum_without_descriptions_test
+---
+enum Color {
+  RED
+  GREEN
+  BLUE
+}

birdie_snapshots/execute_field_with_object_argument.accepted

···
+---
+version: 1.4.1
+title: Execute field with object argument
+file: ./test/executor_test.gleam
+test_name: execute_field_receives_object_argument_test
+---
+Response(Object([#("posts", String("Sorting by date DESC"))]), [])

birdie_snapshots/execute_field_with_string_argument.accepted

···
+---
+version: 1.4.1
+title: Execute field with string argument
+file: ./test/executor_test.gleam
+test_name: execute_field_receives_string_argument_test
+---
+Response(Object([#("echo", String("Echo: hello"))]), [])

birdie_snapshots/execute_list_with_nested_selections.accepted

···
+---
+version: 1.4.1
+title: Execute list with nested selections
+file: ./test/executor_test.gleam
+test_name: execute_list_with_nested_selections_test
+---
+Response(Object([#("users", List([Object([#("id", String("1")), #("name", String("Alice"))]), Object([#("id", String("2")), #("name", String("Bob"))])]))]), [])

birdie_snapshots/execute_mixed_aliased_and_non_aliased_fields.accepted

···
+---
+version: 1.4.1
+title: Execute mixed aliased and non-aliased fields
+file: ./test/executor_test.gleam
+test_name: execute_mixed_aliased_fields_test
+---
+Response(Object([#("greeting", String("world")), #("number", Int(42))]), [])

birdie_snapshots/execute_multiple_fields_with_aliases.accepted

···
+---
+version: 1.4.1
+title: Execute multiple fields with aliases
+file: ./test/executor_test.gleam
+test_name: execute_multiple_fields_with_aliases_test
+---
+Response(Object([#("greeting", String("world")), #("num", Int(42))]), [])

birdie_snapshots/execute_multiple_mutations.accepted

···
+---
+version: 1.4.1
+title: Execute multiple mutations
+file: ./test/mutation_execution_test.gleam
+test_name: execute_multiple_mutations_test
+---
+Response(Object([#("createUser", Object([#("id", String("123")), #("name", String("Alice"))])), #("deleteUser", Boolean(True))]), [])

birdie_snapshots/execute_query_with_int_variable.accepted

···
+---
+version: 1.4.1
+title: Execute query with int variable
+file: ./test/executor_test.gleam
+test_name: execute_query_with_variable_int_test
+---
+Response(Object([#("user", String("User #42"))]), [])

birdie_snapshots/execute_query_with_multiple_variables.accepted

···
+---
+version: 1.4.1
+title: Execute query with multiple variables
+file: ./test/executor_test.gleam
+test_name: execute_query_with_multiple_variables_test
+---
+Response(Object([#("search", String("Searching for 'graphql' (limit: 10)"))]), [])

birdie_snapshots/execute_query_with_string_variable.accepted

···
+---
+version: 1.4.1
+title: Execute query with string variable
+file: ./test/executor_test.gleam
+test_name: execute_query_with_variable_string_test
+---
+Response(Object([#("greet", String("Hello, Alice!"))]), [])

birdie_snapshots/execute_schema_introspection.accepted

···
+---
+version: 1.4.1
+title: Execute __schema introspection
+file: ./test/executor_test.gleam
+test_name: execute_schema_introspection_query_type_test
+---
+Response(Object([#("__schema", Object([#("queryType", Object([#("name", String("Query"))]))]))]), [])

birdie_snapshots/execute_simple_fragment_spread.accepted

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

birdie_snapshots/execute_simple_mutation.accepted

···
+---
+version: 1.4.1
+title: Execute simple mutation
+file: ./test/mutation_execution_test.gleam
+test_name: execute_simple_mutation_test
+---
+Response(Object([#("createUser", Object([#("id", String("123")), #("name", String("Alice"))]))]), [])

birdie_snapshots/execute_simple_query.accepted

···
+---
+version: 1.4.1
+title: Execute simple query
+file: ./test/executor_test.gleam
+test_name: execute_simple_query_test
+---
+Response(Object([#("hello", String("world"))]), [])

birdie_snapshots/execute_typename_introspection.accepted

···
+---
+version: 1.4.1
+title: Execute __typename introspection
+file: ./test/executor_test.gleam
+test_name: execute_typename_introspection_test
+---
+Response(Object([#("__typename", String("Query"))]), [])

birdie_snapshots/execute_typename_with_regular_fields.accepted

···
+---
+version: 1.4.1
+title: Execute __typename with regular fields
+file: ./test/executor_test.gleam
+test_name: execute_typename_with_regular_fields_test
+---
+Response(Object([#("__typename", String("Query")), #("hello", String("world"))]), [])

birdie_snapshots/execute_union_list_with_inline_fragments.accepted

···
+---
+version: 1.4.1
+title: Execute union list with inline fragments
+file: ./test/executor_test.gleam
+test_name: execute_union_list_with_inline_fragments_test
+---
+Response(Object([#("searchAll", List([Object([#("title", String("First Post"))]), Object([#("text", String("Great article!"))]), Object([#("title", String("Second Post"))])]))]), [])

birdie_snapshots/execute_union_with_inline_fragment.accepted

···
+---
+version: 1.4.1
+title: Execute union with inline fragment
+file: ./test/executor_test.gleam
+test_name: execute_union_with_inline_fragment_test
+---
+Response(Object([#("search", Object([#("title", String("GraphQL is awesome")), #("content", String("Learn all about GraphQL..."))]))]), [])

birdie_snapshots/input_object_with_default_values.accepted

···
+---
+version: 1.4.1
+title: Input object with default values
+file: ./test/sdl_test.gleam
+test_name: input_object_with_default_values_test
+---
+"""Filter options for queries"""
+input FilterInput {
+  """Maximum number of results"""
+  limit: Int
+  """Number of results to skip"""
+  offset: Int
+}

birdie_snapshots/multiple_mutations_(_crud_operations).accepted

···
+---
+version: 1.4.1
+title: Multiple mutations (CRUD operations)
+file: ./test/mutation_sdl_test.gleam
+test_name: multiple_mutations_test
+---
+"""Mutations"""
+type Mutation {
+  """Create a user"""
+  createUser: User
+  """Update a user"""
+  updateUser: User
+  """Delete a user"""
+  deleteUser: DeleteResponse
+}

birdie_snapshots/multiple_mutations_in_one_operation.accepted

···
+---
+version: 1.4.1
+title: Multiple mutations in one operation
+file: ./test/mutation_parser_test.gleam
+test_name: parse_multiple_mutations_test
+---
+Document([Mutation(SelectionSet([Field("createUser", None, [Argument("name", StringValue("Alice"))], [Field("id", None, [], [])]), Field("deleteUser", None, [Argument("id", StringValue("123"))], [Field("success", None, [], [])])]))])

birdie_snapshots/multiple_related_types.accepted

···
+---
+version: 1.4.1
+title: Multiple related types
+file: ./test/sdl_test.gleam
+test_name: related_types_test
+---
+"""Sort direction for queries"""
+enum SortDirection {
+  """Ascending order"""
+  ASC
+  """Descending order"""
+  DESC
+}
+
+"""Fields to sort users by"""
+enum UserSortField {
+  """Sort by name"""
+  NAME
+  """Sort by email"""
+  EMAIL
+  """Sort by creation date"""
+  CREATED_AT
+}
+
+"""Sort configuration"""
+input SortInput {
+  """Field to sort by"""
+  field: UserSortField!
+  """Sort direction"""
+  direction: SortDirection
+}

birdie_snapshots/mutation_returning_list.accepted

···
+---
+version: 1.4.1
+title: Mutation returning list
+file: ./test/mutation_sdl_test.gleam
+test_name: mutation_returning_list_test
+---
+"""Mutations"""
+type Mutation {
+  """Create multiple users"""
+  createUsers: [User]
+}

birdie_snapshots/mutation_with_input_object_argument.accepted

···
+---
+version: 1.4.1
+title: Mutation with input object argument
+file: ./test/mutation_sdl_test.gleam
+test_name: mutation_with_input_object_test
+---
+"""Input for creating a user"""
+input CreateUserInput {
+  """User name"""
+  name: String!
+  """Email address"""
+  email: String!
+  """Age"""
+  age: Int
+}
+
+"""A user"""
+type User {
+  """User ID"""
+  id: ID
+  """User name"""
+  name: String
+}
+
+"""Mutations"""
+type Mutation {
+  """Create a new user"""
+  createUser: User
+}

birdie_snapshots/mutation_with_nested_selections.accepted

···
+---
+version: 1.4.1
+title: Mutation with nested selections
+file: ./test/mutation_parser_test.gleam
+test_name: parse_mutation_with_nested_selections_test
+---
+Document([Mutation(SelectionSet([Field("createPost", None, [Argument("input", ObjectValue([#("title", StringValue("Hello"))]))], [Field("id", None, [], []), Field("author", None, [], [Field("id", None, [], []), Field("name", None, [], [])]), Field("tags", None, [], [])])]))])

birdie_snapshots/mutation_with_non_null_return_type.accepted

···
+---
+version: 1.4.1
+title: Mutation with non-null return type
+file: ./test/mutation_sdl_test.gleam
+test_name: mutation_with_non_null_return_test
+---
+"""Mutations"""
+type Mutation {
+  """Create a user (guaranteed to return)"""
+  createUser: User!
+}

birdie_snapshots/named_mutation.accepted

···
+---
+version: 1.4.1
+title: Named mutation
+file: ./test/mutation_parser_test.gleam
+test_name: parse_named_mutation_test
+---
+Document([NamedMutation("CreateUser", [], SelectionSet([Field("createUser", None, [Argument("name", StringValue("Alice"))], [Field("id", None, [], []), Field("name", None, [], [])])]))])

birdie_snapshots/named_subscription.accepted

···
+---
+version: 1.4.1
+title: Named subscription
+file: ./test/subscription_parser_test.gleam
+test_name: parse_named_subscription_test
+---
+Document([NamedSubscription("OnMessage", [], SelectionSet([Field("messageAdded", None, [], [Field("id", None, [], []), Field("content", None, [], [])])]))])

birdie_snapshots/nested_input_types.accepted

···
+---
+version: 1.4.1
+title: Nested input types
+file: ./test/sdl_test.gleam
+test_name: nested_input_types_test
+---
+"""Street address information"""
+input AddressInput {
+  """Street name"""
+  street: String
+  """City name"""
+  city: String
+}
+
+"""User information"""
+input UserInput {
+  """Full name"""
+  name: String
+  """Home address"""
+  address: AddressInput
+}

birdie_snapshots/object_type_with_list_fields.accepted

···
+---
+version: 1.4.1
+title: Object type with list fields
+file: ./test/sdl_test.gleam
+test_name: object_with_list_fields_test
+---
+"""A blog post"""
+type Post {
+  """Post ID"""
+  id: ID
+  """Post title"""
+  title: String
+  """Post tags"""
+  tags: [String!]
+}

birdie_snapshots/parse_mutation_with_input_object_argument.accepted

···
+---
+version: 1.4.1
+title: Parse mutation with input object argument
+file: ./test/mutation_parser_test.gleam
+test_name: parse_mutation_with_input_object_test
+---
+Document([Mutation(SelectionSet([Field("createUser", None, [Argument("input", ObjectValue([#("name", StringValue("Alice")), #("email", StringValue("[e-mail]")), #("age", IntValue("30"))]))], [Field("id", None, [], []), Field("name", None, [], []), Field("email", None, [], [])])]))])

birdie_snapshots/simple_anonymous_mutation.accepted

···
+---
+version: 1.4.1
+title: Simple anonymous mutation
+file: ./test/mutation_parser_test.gleam
+test_name: parse_simple_anonymous_mutation_test
+---
+Document([Mutation(SelectionSet([Field("createUser", None, [Argument("name", StringValue("Alice"))], [Field("id", None, [], []), Field("name", None, [], [])])]))])

birdie_snapshots/simple_anonymous_subscription.accepted

···
+---
+version: 1.4.1
+title: Simple anonymous subscription
+file: ./test/subscription_parser_test.gleam
+test_name: parse_simple_anonymous_subscription_test
+---
+Document([Subscription(SelectionSet([Field("messageAdded", None, [], [Field("content", None, [], []), Field("author", None, [], [])])]))])

birdie_snapshots/simple_enum_type.accepted

···
+---
+version: 1.4.1
+title: Simple enum type
+file: ./test/sdl_test.gleam
+test_name: simple_enum_test
+---
+"""Order status"""
+enum Status {
+  """Order is pending"""
+  PENDING
+  """Order is being processed"""
+  PROCESSING
+  """Order has been shipped"""
+  SHIPPED
+  """Order has been delivered"""
+  DELIVERED
+}

birdie_snapshots/simple_input_object_with_descriptions.accepted

···
+---
+version: 1.4.1
+title: Simple input object with descriptions
+file: ./test/sdl_test.gleam
+test_name: simple_input_object_test
+---
+"""Input for creating or updating a user"""
+input UserInput {
+  """User's name"""
+  name: String
+  """User's email address"""
+  email: String!
+  """User's age"""
+  age: Int
+}

birdie_snapshots/simple_mutation_type.accepted

···
+---
+version: 1.4.1
+title: Simple mutation type
+file: ./test/mutation_sdl_test.gleam
+test_name: simple_mutation_type_test
+---
+"""Root mutation type"""
+type Mutation {
+  """Create a new user"""
+  createUser: User
+}

birdie_snapshots/simple_object_type.accepted

···
+---
+version: 1.4.1
+title: Simple object type
+file: ./test/sdl_test.gleam
+test_name: simple_object_type_test
+---
+"""A user in the system"""
+type User {
+  """User ID"""
+  id: ID!
+  """User's name"""
+  name: String
+  """Email address"""
+  email: String
+}

birdie_snapshots/subscription_with_nested_selections.accepted

···
+---
+version: 1.4.1
+title: Subscription with nested selections
+file: ./test/subscription_parser_test.gleam
+test_name: parse_subscription_with_nested_selections_test
+---
+Document([Subscription(SelectionSet([Field("postCreated", None, [], [Field("id", None, [], []), Field("title", None, [], []), Field("author", None, [], [Field("id", None, [], []), Field("name", None, [], []), Field("email", None, [], [])]), Field("comments", None, [], [Field("content", None, [], [])])])]))])

birdie_snapshots/type_with_non_null_and_list_modifiers.accepted

···
+---
+version: 1.4.1
+title: Type with NonNull and List modifiers
+file: ./test/sdl_test.gleam
+test_name: type_with_non_null_and_list_test
+---
+"""Complex type modifiers"""
+input ComplexInput {
+  """Required string"""
+  required: String!
+  """Optional list of strings"""
+  optionalList: [String]
+  """Required list of optional strings"""
+  requiredList: [String]!
+  """Optional list of required strings"""
+  listOfRequired: [String!]
+  """Required list of required strings"""
+  requiredListOfRequired: [String!]!
+}

example/README.md

···
+# example
+
+[![Package Version](https://img.shields.io/hexpm/v/example)](https://hex.pm/packages/example)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/example/)
+
+```sh
+gleam add example@1
+```
+```gleam
+import example
+
+pub fn main() -> Nil {
+  // TODO: An example of the project in use
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/example>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```

example/gleam.toml

···
+name = "example"
+version = "1.0.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# description = ""
+# licences = ["Apache-2.0"]
+# repository = { type = "github", user = "", repo = "" }
+# links = [{ title = "Website", href = "" }]
+#
+# For a full reference of all the available options, you can have a look at
+# https://gleam.run/writing-gleam/gleam-toml/.
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+sqlight = ">= 1.0.0 and < 2.0.0"
+swell = { path = ".." }
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"

example/manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "esqlite", version = "0.9.0", build_tools = ["rebar3"], requirements = [], otp_app = "esqlite", source = "hex", outer_checksum = "CCF72258A4EE152EC7AD92AA9A03552EB6CA1B06B65C93AD5B6E55C302E05855" },
+  { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
+  { name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" },
+  { name = "sqlight", version = "1.0.3", build_tools = ["gleam"], requirements = ["esqlite", "gleam_stdlib"], otp_app = "sqlight", source = "hex", outer_checksum = "CADD79663C9B61D4BAC960A47CC2D42CA8F48EAF5804DBEB79977287750F4B16" },
+  { name = "swell", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], source = "local", path = ".." },
+]
+
+[requirements]
+gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
+sqlight = { version = ">= 1.0.0 and < 2.0.0" }
+swell = { path = ".." }

example/src/database.gleam

···
+import gleam/dynamic/decode
+import gleam/result
+import gleam/string
+import sqlight
+
+pub type User {
+  User(id: Int, name: String, email: String)
+}
+
+pub type Post {
+  Post(id: Int, title: String, content: String, author_id: Int)
+}
+
+/// Create an in-memory database with users and posts tables
+pub fn setup_database() -> Result(sqlight.Connection, sqlight.Error) {
+  use conn <- result.try(sqlight.open(":memory:"))
+
+  // Create users table
+  let users_sql =
+    "
+    CREATE TABLE users (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      email TEXT NOT NULL
+    )
+  "
+
+  use _ <- result.try(sqlight.exec(users_sql, conn))
+
+  // Create posts table
+  let posts_sql =
+    "
+    CREATE TABLE posts (
+      id INTEGER PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      author_id INTEGER NOT NULL,
+      FOREIGN KEY (author_id) REFERENCES users(id)
+    )
+  "
+
+  use _ <- result.try(sqlight.exec(posts_sql, conn))
+
+  // Insert sample users (surfers)
+  let insert_users =
+    "
+    INSERT INTO users (id, name, email) VALUES
+      (1, 'Coco Ho', '[e-mail]'),
+      (2, 'Carissa Moore', '[e-mail]'),
+      (3, 'Kelly Slater', '[e-mail]')
+  "
+
+  use _ <- result.try(sqlight.exec(insert_users, conn))
+
+  // Insert sample posts (surf reports and stories)
+  let insert_posts =
+    "
+    INSERT INTO posts (id, title, content, author_id) VALUES
+      (1, 'Sick Barrels at Pipe', 'Bruh, Pipeline was absolutely firing today! Scored some gnarly 8ft tubes, got shacked so hard. Offshore winds all day, totally glassy. So stoked!', 1),
+      (2, 'Sunset Bombing', 'Just got done charging some heavy sets at Sunset. Waves were massive, super clean faces. If you are not out here you are missing out big time brah!', 1),
+      (3, 'Epic Dawn Patrol Session', 'Woke up at 5am for dawn patrol and it was totally worth it dude. Glassy perfection, no kooks in the lineup. Just me and the ocean vibing. Radical!', 2),
+      (4, 'Tow-in at Jaws Was Insane', 'Yo, just finished tow-in session at Jaws. 50 footers rolling through, absolutely gnarly! Got worked on one bomb but that is part of the game. Respect the ocean always bruh.', 3)
+  "
+
+  use _ <- result.try(sqlight.exec(insert_posts, conn))
+
+  Ok(conn)
+}
+
+/// Get all users from the database
+pub fn get_users(conn: sqlight.Connection) -> List(User) {
+  let sql = "SELECT id, name, email FROM users"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use name <- decode.field(1, decode.string)
+    use email <- decode.field(2, decode.string)
+    decode.success(User(id:, name:, email:))
+  }
+
+  sqlight.query(sql, on: conn, with: [], expecting: decoder)
+  |> result.unwrap([])
+}
+
+/// Get a user by ID
+pub fn get_user(
+  conn: sqlight.Connection,
+  user_id: Int,
+) -> Result(User, String) {
+  let sql = "SELECT id, name, email FROM users WHERE id = ?"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use name <- decode.field(1, decode.string)
+    use email <- decode.field(2, decode.string)
+    decode.success(User(id:, name:, email:))
+  }
+
+  case
+    sqlight.query(sql, on: conn, with: [sqlight.int(user_id)], expecting: decoder)
+  {
+    Ok([user]) -> Ok(user)
+    Ok([]) -> Error("User not found")
+    Ok(_) -> Error("Multiple users found")
+    Error(err) -> Error("Database error: " <> string.inspect(err))
+  }
+}
+
+/// Get all posts from the database
+pub fn get_posts(conn: sqlight.Connection) -> List(Post) {
+  let sql = "SELECT id, title, content, author_id FROM posts"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use title <- decode.field(1, decode.string)
+    use content <- decode.field(2, decode.string)
+    use author_id <- decode.field(3, decode.int)
+    decode.success(Post(id:, title:, content:, author_id:))
+  }
+
+  sqlight.query(sql, on: conn, with: [], expecting: decoder)
+  |> result.unwrap([])
+}
+
+/// Get a post by ID
+pub fn get_post(conn: sqlight.Connection, post_id: Int) -> Result(Post, String) {
+  let sql = "SELECT id, title, content, author_id FROM posts WHERE id = ?"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use title <- decode.field(1, decode.string)
+    use content <- decode.field(2, decode.string)
+    use author_id <- decode.field(3, decode.int)
+    decode.success(Post(id:, title:, content:, author_id:))
+  }
+
+  case
+    sqlight.query(sql, on: conn, with: [sqlight.int(post_id)], expecting: decoder)
+  {
+    Ok([post]) -> Ok(post)
+    Ok([]) -> Error("Post not found")
+    Ok(_) -> Error("Multiple posts found")
+    Error(err) -> Error("Database error: " <> string.inspect(err))
+  }
+}
+
+/// Get posts by author ID
+pub fn get_posts_by_author(
+  conn: sqlight.Connection,
+  author_id: Int,
+) -> List(Post) {
+  let sql = "SELECT id, title, content, author_id FROM posts WHERE author_id = ?"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use title <- decode.field(1, decode.string)
+    use content <- decode.field(2, decode.string)
+    use author_id <- decode.field(3, decode.int)
+    decode.success(Post(id:, title:, content:, author_id:))
+  }
+
+  sqlight.query(
+    sql,
+    on: conn,
+    with: [sqlight.int(author_id)],
+    expecting: decoder,
+  )
+  |> result.unwrap([])
+}
+
+/// Create a new user
+pub fn create_user(
+  conn: sqlight.Connection,
+  name: String,
+  email: String,
+) -> Result(User, String) {
+  let sql = "INSERT INTO users (name, email) VALUES (?, ?) RETURNING id, name, email"
+
+  let decoder = {
+    use id <- decode.field(0, decode.int)
+    use name <- decode.field(1, decode.string)
+    use email <- decode.field(2, decode.string)
+    decode.success(User(id:, name:, email:))
+  }
+
+  case
+    sqlight.query(
+      sql,
+      on: conn,
+      with: [sqlight.text(name), sqlight.text(email)],
+      expecting: decoder,
+    )
+  {
+    Ok([user]) -> Ok(user)
+    Ok([]) -> Error("Failed to create user")
+    Ok(_) -> Error("Unexpected result")
+    Error(err) -> Error("Database error: " <> string.inspect(err))
+  }
+}

example/src/example.gleam

···
+import database
+import gleam/io
+import gleam/option
+import gleam/string
+import graphql_schema
+import swell/executor
+import swell/schema
+
+pub fn main() -> Nil {
+  io.println("🌊 Swell + SQLite Example")
+  io.println("=" |> string.repeat(50))
+  io.println("")
+
+  // Setup in-memory SQLite database
+  io.println("Setting up in-memory SQLite database...")
+  let assert Ok(conn) = database.setup_database()
+  io.println("✓ Database initialized with sample data")
+  io.println("")
+
+  // Build GraphQL schema
+  let graphql_schema = graphql_schema.build_schema(conn)
+  io.println("✓ GraphQL schema created")
+  io.println("")
+
+  // Example 1: Query all users
+  io.println("Query 1: Get all users")
+  io.println("-" |> string.repeat(50))
+  let query1 = "{ users { id name email } }"
+  io.println("GraphQL: " <> query1)
+  io.println("")
+
+  let ctx1 = schema.context(option.None)
+  case executor.execute(query1, graphql_schema, ctx1) {
+    Ok(executor.Response(data: data, errors: [])) -> {
+      io.println("Result: " <> string.inspect(data))
+    }
+    Ok(executor.Response(data: data, errors: errors)) -> {
+      io.println("Data: " <> string.inspect(data))
+      io.println("Errors: " <> string.inspect(errors))
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+    }
+  }
+  io.println("")
+
+  // Example 2: Query a specific user by ID
+  io.println("Query 2: Get user with ID 1")
+  io.println("-" |> string.repeat(50))
+  let query2 = "{ user(id: 1) { id name email } }"
+  io.println("GraphQL: " <> query2)
+  io.println("")
+
+  let ctx2 = schema.context(option.None)
+  case executor.execute(query2, graphql_schema, ctx2) {
+    Ok(executor.Response(data: data, errors: [])) -> {
+      io.println("Result: " <> string.inspect(data))
+    }
+    Ok(executor.Response(data: data, errors: errors)) -> {
+      io.println("Data: " <> string.inspect(data))
+      io.println("Errors: " <> string.inspect(errors))
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+    }
+  }
+  io.println("")
+
+  // Example 3: Query all posts
+  io.println("Query 3: Get all posts")
+  io.println("-" |> string.repeat(50))
+  let query3 = "{ posts { id title content authorId } }"
+  io.println("GraphQL: " <> query3)
+  io.println("")
+
+  let ctx3 = schema.context(option.None)
+  case executor.execute(query3, graphql_schema, ctx3) {
+    Ok(executor.Response(data: data, errors: [])) -> {
+      io.println("Result: " <> string.inspect(data))
+    }
+    Ok(executor.Response(data: data, errors: errors)) -> {
+      io.println("Data: " <> string.inspect(data))
+      io.println("Errors: " <> string.inspect(errors))
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+    }
+  }
+  io.println("")
+
+  // Example 4: Create a new user with a mutation
+  io.println("Mutation 1: Create a new user")
+  io.println("-" |> string.repeat(50))
+  let mutation1 =
+    "mutation { createUser(input: { name: \"Stephanie Gilmore\", email: \"[e-mail]\" }) { id name email } }"
+  io.println("GraphQL: " <> mutation1)
+  io.println("")
+
+  let ctx4 = schema.context(option.None)
+  case executor.execute(mutation1, graphql_schema, ctx4) {
+    Ok(executor.Response(data: data, errors: [])) -> {
+      io.println("Result: " <> string.inspect(data))
+    }
+    Ok(executor.Response(data: data, errors: errors)) -> {
+      io.println("Data: " <> string.inspect(data))
+      io.println("Errors: " <> string.inspect(errors))
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+    }
+  }
+  io.println("")
+
+  // Example 5: Query the newly created user
+  io.println("Query 4: Verify the new user was created")
+  io.println("-" |> string.repeat(50))
+  let query5 = "{ users { id name email } }"
+  io.println("GraphQL: " <> query5)
+  io.println("")
+
+  let ctx5 = schema.context(option.None)
+  case executor.execute(query5, graphql_schema, ctx5) {
+    Ok(executor.Response(data: data, errors: [])) -> {
+      io.println("Result: " <> string.inspect(data))
+    }
+    Ok(executor.Response(data: data, errors: errors)) -> {
+      io.println("Data: " <> string.inspect(data))
+      io.println("Errors: " <> string.inspect(errors))
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+    }
+  }
+  io.println("")
+
+  io.println("=" |> string.repeat(50))
+  io.println("✓ All examples completed!")
+}

example/src/graphql_schema.gleam

···
+import database
+import gleam/int
+import gleam/list
+import gleam/option.{None, Some}
+import sqlight
+import swell/schema
+import swell/value
+
+/// Build the User type (without nested posts to avoid circular dependency)
+pub fn user_type() -> schema.Type {
+  schema.object_type("User", "A user in the system", [
+    schema.field("id", schema.id_type(), "User ID", fn(ctx) {
+      case ctx.data {
+        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("name", schema.string_type(), "User name", fn(ctx) {
+      case ctx.data {
+        Some(value.Object(fields)) -> {
+          case list.key_find(fields, "name") {
+            Ok(name_val) -> Ok(name_val)
+            Error(_) -> Ok(value.Null)
+          }
+        }
+        _ -> Ok(value.Null)
+      }
+    }),
+    schema.field("email", schema.string_type(), "User email", fn(ctx) {
+      case ctx.data {
+        Some(value.Object(fields)) -> {
+          case list.key_find(fields, "email") {
+            Ok(email_val) -> Ok(email_val)
+            Error(_) -> Ok(value.Null)
+          }
+        }
+        _ -> Ok(value.Null)
+      }
+    }),
+  ])
+}
+
+/// Build the Post type (without nested author to avoid circular dependency)
+pub fn post_type() -> schema.Type {
+  schema.object_type("Post", "A blog post", [
+    schema.field("id", schema.id_type(), "Post ID", fn(ctx) {
+      case ctx.data {
+        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(), "Post title", fn(ctx) {
+      case ctx.data {
+        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("content", schema.string_type(), "Post content", fn(ctx) {
+      case ctx.data {
+        Some(value.Object(fields)) -> {
+          case list.key_find(fields, "content") {
+            Ok(content_val) -> Ok(content_val)
+            Error(_) -> Ok(value.Null)
+          }
+        }
+        _ -> Ok(value.Null)
+      }
+    }),
+    schema.field("authorId", schema.int_type(), "Author ID", fn(ctx) {
+      case ctx.data {
+        Some(value.Object(fields)) -> {
+          case list.key_find(fields, "author_id") {
+            Ok(author_id_val) -> Ok(author_id_val)
+            Error(_) -> Ok(value.Null)
+          }
+        }
+        _ -> Ok(value.Null)
+      }
+    }),
+  ])
+}
+
+/// Convert a User to a GraphQL Value
+fn user_to_value(user: database.User) -> value.Value {
+  value.Object([
+    #("id", value.Int(user.id)),
+    #("name", value.String(user.name)),
+    #("email", value.String(user.email)),
+  ])
+}
+
+/// Convert a Post to a GraphQL Value
+fn post_to_value(post: database.Post) -> value.Value {
+  value.Object([
+    #("id", value.Int(post.id)),
+    #("title", value.String(post.title)),
+    #("content", value.String(post.content)),
+    #("author_id", value.Int(post.author_id)),
+  ])
+}
+
+/// Build the Query type
+pub fn query_type(conn: sqlight.Connection) -> schema.Type {
+  schema.object_type("Query", "Root query type", [
+    schema.field("users", schema.list_type(user_type()), "Get all users", fn(
+      _ctx,
+    ) {
+      let users = database.get_users(conn)
+      Ok(value.List(list.map(users, user_to_value)))
+    }),
+    schema.field_with_args(
+      "user",
+      user_type(),
+      "Get a user by ID",
+      [
+        schema.argument(
+          "id",
+          schema.non_null(schema.id_type()),
+          "User ID",
+          None,
+        ),
+      ],
+      fn(ctx) {
+        case schema.get_argument(ctx, "id") {
+          Some(value.Int(user_id)) -> {
+            case database.get_user(conn, user_id) {
+              Ok(user) -> Ok(user_to_value(user))
+              Error(err) -> Error(err)
+            }
+          }
+          Some(value.String(user_id_str)) -> {
+            case int.parse(user_id_str) {
+              Ok(user_id) -> {
+                case database.get_user(conn, user_id) {
+                  Ok(user) -> Ok(user_to_value(user))
+                  Error(err) -> Error(err)
+                }
+              }
+              Error(_) -> Error("Invalid user ID format")
+            }
+          }
+          _ -> Error("User ID is required")
+        }
+      },
+    ),
+    schema.field("posts", schema.list_type(post_type()), "Get all posts", fn(
+      _ctx,
+    ) {
+      let posts = database.get_posts(conn)
+      Ok(value.List(list.map(posts, post_to_value)))
+    }),
+    schema.field_with_args(
+      "post",
+      post_type(),
+      "Get a post by ID",
+      [
+        schema.argument(
+          "id",
+          schema.non_null(schema.id_type()),
+          "Post ID",
+          None,
+        ),
+      ],
+      fn(ctx) {
+        case schema.get_argument(ctx, "id") {
+          Some(value.Int(post_id)) -> {
+            case database.get_post(conn, post_id) {
+              Ok(post) -> Ok(post_to_value(post))
+              Error(err) -> Error(err)
+            }
+          }
+          Some(value.String(post_id_str)) -> {
+            case int.parse(post_id_str) {
+              Ok(post_id) -> {
+                case database.get_post(conn, post_id) {
+                  Ok(post) -> Ok(post_to_value(post))
+                  Error(err) -> Error(err)
+                }
+              }
+              Error(_) -> Error("Invalid post ID format")
+            }
+          }
+          _ -> Error("Post ID is required")
+        }
+      },
+    ),
+  ])
+}
+
+/// Input type for creating a user
+pub fn create_user_input() -> schema.Type {
+  schema.input_object_type("CreateUserInput", "Input for creating a user", [
+    schema.input_field(
+      "name",
+      schema.non_null(schema.string_type()),
+      "User name",
+      None,
+    ),
+    schema.input_field(
+      "email",
+      schema.non_null(schema.string_type()),
+      "User email",
+      None,
+    ),
+  ])
+}
+
+/// Build the Mutation type
+pub fn mutation_type(conn: sqlight.Connection) -> schema.Type {
+  schema.object_type("Mutation", "Root mutation type", [
+    schema.field_with_args(
+      "createUser",
+      user_type(),
+      "Create a new user",
+      [
+        schema.argument(
+          "input",
+          schema.non_null(create_user_input()),
+          "User data",
+          None,
+        ),
+      ],
+      fn(ctx) {
+        case schema.get_argument(ctx, "input") {
+          Some(value.Object(fields)) -> {
+            let name_result = list.key_find(fields, "name")
+            let email_result = list.key_find(fields, "email")
+
+            case name_result, email_result {
+              Ok(value.String(name)), Ok(value.String(email)) -> {
+                case database.create_user(conn, name, email) {
+                  Ok(user) -> Ok(user_to_value(user))
+                  Error(err) -> Error(err)
+                }
+              }
+              _, _ -> Error("Invalid input: name and email are required")
+            }
+          }
+          _ -> Error("Invalid input format")
+        }
+      },
+    ),
+  ])
+}
+
+/// Build the complete GraphQL schema
+pub fn build_schema(conn: sqlight.Connection) -> schema.Schema {
+  schema.schema(query_type(conn), Some(mutation_type(conn)))
+}

example/test/example_test.gleam

···
+import gleeunit
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  let name = "Joe"
+  let greeting = "Hello, " <> name <> "!"
+
+  assert greeting == "Hello, Joe!"
+}

gleam.toml

···
+name = "swell"
+version = "1.0.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# description = ""
+# licences = ["Apache-2.0"]
+# repository = { type = "github", user = "", repo = "" }
+# links = [{ title = "Website", href = "" }]
+#
+# For a full reference of all the available options, you can have a look at
+# https://gleam.run/writing-gleam/gleam-toml/.
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"
+birdie = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
+  { name = "birdie", version = "1.4.1", build_tools = ["gleam"], requirements = ["argv", "edit_distance", "filepath", "glance", "gleam_community_ansi", "gleam_stdlib", "justin", "rank", "simplifile", "term_size", "trie_again"], otp_app = "birdie", source = "hex", outer_checksum = "18599E478C14BD9EBD2465F0561F96EB9B58A24DB44AF86F103EF81D4B9834BF" },
+  { name = "edit_distance", version = "3.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "edit_distance", source = "hex", outer_checksum = "7DC465C34695F9E57D79FC65670C53C992CE342BF29E0AA41FF44F61AF62FC56" },
+  { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
+  { name = "glance", version = "5.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib", "glexer"], otp_app = "glance", source = "hex", outer_checksum = "7F216D97935465FF4AC46699CD1C3E0FB19CB678B002E4ACAFCE256E96312F14" },
+  { name = "gleam_community_ansi", version = "1.4.3", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_regexp", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "8A62AE9CC6EA65BEA630D95016D6C07E4F9973565FA3D0DE68DC4200D8E0DD27" },
+  { name = "gleam_community_colour", version = "2.0.2", build_tools = ["gleam"], requirements = ["gleam_json", "gleam_stdlib"], otp_app = "gleam_community_colour", source = "hex", outer_checksum = "E34DD2C896AC3792151EDA939DA435FF3B69922F33415ED3C4406C932FBE9634" },
+  { name = "gleam_json", version = "3.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "874FA3C3BB6E22DD2BB111966BD40B3759E9094E05257899A7C08F5DE77EC049" },
+  { name = "gleam_regexp", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_regexp", source = "hex", outer_checksum = "9C215C6CA84A5B35BB934A9B61A9A306EC743153BE2B0425A0D032E477B062A9" },
+  { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
+  { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },
+  { name = "glexer", version = "2.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "splitter"], otp_app = "glexer", source = "hex", outer_checksum = "40A1FB0919FA080AD6C5809B4C7DBA545841CAAC8168FACDFA0B0667C22475CC" },
+  { name = "justin", version = "1.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "justin", source = "hex", outer_checksum = "7FA0C6DB78640C6DC5FBFD59BF3456009F3F8B485BF6825E97E1EB44E9A1E2CD" },
+  { name = "rank", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "rank", source = "hex", outer_checksum = "5660E361F0E49CBB714CC57CC4C89C63415D8986F05B2DA0C719D5642FAD91C9" },
+  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
+  { name = "splitter", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "splitter", source = "hex", outer_checksum = "05564A381580395DCDEFF4F88A64B021E8DAFA6540AE99B4623962F52976AA9D" },
+  { name = "term_size", version = "1.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "term_size", source = "hex", outer_checksum = "D00BD2BC8FB3EBB7E6AE076F3F1FF2AC9D5ED1805F004D0896C784D06C6645F1" },
+  { name = "trie_again", version = "1.1.4", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "trie_again", source = "hex", outer_checksum = "E3BD66B4E126EF567EA8C4944EAB216413392ADF6C16C36047AF79EE5EF13466" },
+]
+
+[requirements]
+birdie = { version = ">= 1.0.0 and < 2.0.0" }
+gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

src/swell/connection.gleam

···
+/// GraphQL Connection Types for Relay Cursor Connections
+///
+/// Implements the Relay Cursor Connections Specification:
+/// https://relay.dev/graphql/connections.htm
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import swell/schema
+import swell/value
+
+/// PageInfo type for connection pagination metadata
+pub type PageInfo {
+  PageInfo(
+    has_next_page: Bool,
+    has_previous_page: Bool,
+    start_cursor: Option(String),
+    end_cursor: Option(String),
+  )
+}
+
+/// Edge wrapper containing a node and its cursor
+pub type Edge(node_type) {
+  Edge(node: node_type, cursor: String)
+}
+
+/// Connection wrapper containing edges and page info
+pub type Connection(node_type) {
+  Connection(
+    edges: List(Edge(node_type)),
+    page_info: PageInfo,
+    total_count: Option(Int),
+  )
+}
+
+/// Creates the PageInfo GraphQL type
+pub fn page_info_type() -> schema.Type {
+  schema.object_type(
+    "PageInfo",
+    "Information about pagination in a connection",
+    [
+      schema.field(
+        "hasNextPage",
+        schema.non_null(schema.boolean_type()),
+        "When paginating forwards, are there more items?",
+        fn(ctx) {
+          // Extract from context data
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "hasNextPage") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Boolean(False))
+              }
+            }
+            _ -> Ok(value.Boolean(False))
+          }
+        },
+      ),
+      schema.field(
+        "hasPreviousPage",
+        schema.non_null(schema.boolean_type()),
+        "When paginating backwards, are there more items?",
+        fn(ctx) {
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "hasPreviousPage") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Boolean(False))
+              }
+            }
+            _ -> Ok(value.Boolean(False))
+          }
+        },
+      ),
+      schema.field(
+        "startCursor",
+        schema.string_type(),
+        "Cursor corresponding to the first item in the page",
+        fn(ctx) {
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "startCursor") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Null)
+              }
+            }
+            _ -> Ok(value.Null)
+          }
+        },
+      ),
+      schema.field(
+        "endCursor",
+        schema.string_type(),
+        "Cursor corresponding to the last item in the page",
+        fn(ctx) {
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "endCursor") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Null)
+              }
+            }
+            _ -> Ok(value.Null)
+          }
+        },
+      ),
+    ],
+  )
+}
+
+/// Creates an Edge type for a given node type name
+pub fn edge_type(node_type_name: String, node_type: schema.Type) -> schema.Type {
+  let edge_type_name = node_type_name <> "Edge"
+
+  schema.object_type(
+    edge_type_name,
+    "An edge in a connection for " <> node_type_name,
+    [
+      schema.field(
+        "node",
+        schema.non_null(node_type),
+        "The item at the end of the edge",
+        fn(ctx) {
+          // Extract node from context data
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "node") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Null)
+              }
+            }
+            _ -> Ok(value.Null)
+          }
+        },
+      ),
+      schema.field(
+        "cursor",
+        schema.non_null(schema.string_type()),
+        "A cursor for use in pagination",
+        fn(ctx) {
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "cursor") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.String(""))
+              }
+            }
+            _ -> Ok(value.String(""))
+          }
+        },
+      ),
+    ],
+  )
+}
+
+/// Creates a Connection type for a given node type name
+pub fn connection_type(
+  node_type_name: String,
+  edge_type: schema.Type,
+) -> schema.Type {
+  let connection_type_name = node_type_name <> "Connection"
+
+  schema.object_type(
+    connection_type_name,
+    "A connection to a list of items for " <> node_type_name,
+    [
+      schema.field(
+        "edges",
+        schema.non_null(schema.list_type(schema.non_null(edge_type))),
+        "A list of edges",
+        fn(ctx) {
+          // Extract edges from context data
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "edges") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.List([]))
+              }
+            }
+            _ -> Ok(value.List([]))
+          }
+        },
+      ),
+      schema.field(
+        "pageInfo",
+        schema.non_null(page_info_type()),
+        "Information to aid in pagination",
+        fn(ctx) {
+          // Extract pageInfo from context data
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "pageInfo") {
+                Ok(val) -> Ok(val)
+                Error(_) ->
+                  Ok(
+                    value.Object([
+                      #("hasNextPage", value.Boolean(False)),
+                      #("hasPreviousPage", value.Boolean(False)),
+                      #("startCursor", value.Null),
+                      #("endCursor", value.Null),
+                    ]),
+                  )
+              }
+            }
+            _ ->
+              Ok(
+                value.Object([
+                  #("hasNextPage", value.Boolean(False)),
+                  #("hasPreviousPage", value.Boolean(False)),
+                  #("startCursor", value.Null),
+                  #("endCursor", value.Null),
+                ]),
+              )
+          }
+        },
+      ),
+      schema.field(
+        "totalCount",
+        schema.int_type(),
+        "Total number of items in the connection",
+        fn(ctx) {
+          case ctx.data {
+            Some(value.Object(fields)) -> {
+              case list.key_find(fields, "totalCount") {
+                Ok(val) -> Ok(val)
+                Error(_) -> Ok(value.Null)
+              }
+            }
+            _ -> Ok(value.Null)
+          }
+        },
+      ),
+    ],
+  )
+}
+
+/// Standard pagination arguments for forward pagination
+pub fn forward_pagination_args() -> List(schema.Argument) {
+  [
+    schema.argument(
+      "first",
+      schema.int_type(),
+      "Returns the first n items from the list",
+      None,
+    ),
+    schema.argument(
+      "after",
+      schema.string_type(),
+      "Returns items after the given cursor",
+      None,
+    ),
+  ]
+}
+
+/// Standard pagination arguments for backward pagination
+pub fn backward_pagination_args() -> List(schema.Argument) {
+  [
+    schema.argument(
+      "last",
+      schema.int_type(),
+      "Returns the last n items from the list",
+      None,
+    ),
+    schema.argument(
+      "before",
+      schema.string_type(),
+      "Returns items before the given cursor",
+      None,
+    ),
+  ]
+}
+
+/// All standard connection arguments (forward + backward)
+/// Note: sortBy is not included yet as it requires InputObject type support
+pub fn connection_args() -> List(schema.Argument) {
+  list.flatten([forward_pagination_args(), backward_pagination_args()])
+}
+
+/// Converts a PageInfo value to a GraphQL value
+pub fn page_info_to_value(page_info: PageInfo) -> value.Value {
+  value.Object([
+    #("hasNextPage", value.Boolean(page_info.has_next_page)),
+    #("hasPreviousPage", value.Boolean(page_info.has_previous_page)),
+    #("startCursor", case page_info.start_cursor {
+      Some(cursor) -> value.String(cursor)
+      None -> value.Null
+    }),
+    #("endCursor", case page_info.end_cursor {
+      Some(cursor) -> value.String(cursor)
+      None -> value.Null
+    }),
+  ])
+}
+
+/// Converts an Edge to a GraphQL value
+pub fn edge_to_value(edge: Edge(value.Value)) -> value.Value {
+  value.Object([
+    #("node", edge.node),
+    #("cursor", value.String(edge.cursor)),
+  ])
+}
+
+/// Converts a Connection to a GraphQL value
+pub fn connection_to_value(connection: Connection(value.Value)) -> value.Value {
+  let edges_value =
+    connection.edges
+    |> list.map(edge_to_value)
+    |> value.List
+
+  let total_count_value = case connection.total_count {
+    Some(count) -> value.Int(count)
+    None -> value.Null
+  }
+
+  value.Object([
+    #("edges", edges_value),
+    #("pageInfo", page_info_to_value(connection.page_info)),
+    #("totalCount", total_count_value),
+  ])
+}

src/swell/executor.gleam

···
+/// GraphQL Executor
+///
+/// Executes GraphQL queries against a schema
+import gleam/dict.{type Dict}
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/set.{type Set}
+import swell/introspection
+import swell/parser
+import swell/schema
+import swell/value
+
+/// GraphQL Error
+pub type GraphQLError {
+  GraphQLError(message: String, path: List(String))
+}
+
+/// GraphQL Response
+pub type Response {
+  Response(data: value.Value, errors: List(GraphQLError))
+}
+
+/// Get the response key for a field (alias if present, otherwise field name)
+fn response_key(field_name: String, alias: option.Option(String)) -> String {
+  case alias {
+    option.Some(alias_name) -> alias_name
+    option.None -> field_name
+  }
+}
+
+/// Execute a GraphQL query
+pub fn execute(
+  query: String,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+) -> Result(Response, String) {
+  // Parse the query
+  case parser.parse(query) {
+    Error(parse_error) ->
+      Error("Parse error: " <> format_parse_error(parse_error))
+    Ok(document) -> {
+      // Execute the document
+      case execute_document(document, graphql_schema, ctx) {
+        Ok(#(data, errors)) -> Ok(Response(data, errors))
+        Error(err) -> Error(err)
+      }
+    }
+  }
+}
+
+fn format_parse_error(err: parser.ParseError) -> String {
+  case err {
+    parser.UnexpectedToken(_, msg) -> msg
+    parser.UnexpectedEndOfInput(msg) -> msg
+    parser.LexerError(_) -> "Lexer error"
+  }
+}
+
+/// Execute a document
+fn execute_document(
+  document: parser.Document,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+) -> Result(#(value.Value, List(GraphQLError)), String) {
+  case document {
+    parser.Document(operations) -> {
+      // Separate fragments from executable operations
+      let #(fragments, executable_ops) = partition_operations(operations)
+
+      // Build fragments dictionary
+      let fragments_dict = build_fragments_dict(fragments)
+
+      // Execute the first executable operation
+      case executable_ops {
+        [operation, ..] ->
+          execute_operation(operation, graphql_schema, ctx, fragments_dict)
+        [] -> Error("No executable operations in document")
+      }
+    }
+  }
+}
+
+/// Partition operations into fragments and executable operations
+fn partition_operations(
+  operations: List(parser.Operation),
+) -> #(List(parser.Operation), List(parser.Operation)) {
+  list.partition(operations, fn(op) {
+    case op {
+      parser.FragmentDefinition(_, _, _) -> True
+      _ -> False
+    }
+  })
+}
+
+/// Build a dictionary of fragments keyed by name
+fn build_fragments_dict(
+  fragments: List(parser.Operation),
+) -> Dict(String, parser.Operation) {
+  fragments
+  |> list.filter_map(fn(frag) {
+    case frag {
+      parser.FragmentDefinition(name, _, _) -> Ok(#(name, frag))
+      _ -> Error(Nil)
+    }
+  })
+  |> dict.from_list
+}
+
+/// Execute an operation
+fn execute_operation(
+  operation: parser.Operation,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+  fragments: Dict(String, parser.Operation),
+) -> Result(#(value.Value, List(GraphQLError)), String) {
+  case operation {
+    parser.Query(selection_set) -> {
+      let root_type = schema.query_type(graphql_schema)
+      execute_selection_set(
+        selection_set,
+        root_type,
+        graphql_schema,
+        ctx,
+        fragments,
+        [],
+      )
+    }
+    parser.NamedQuery(_, _, selection_set) -> {
+      let root_type = schema.query_type(graphql_schema)
+      execute_selection_set(
+        selection_set,
+        root_type,
+        graphql_schema,
+        ctx,
+        fragments,
+        [],
+      )
+    }
+    parser.Mutation(selection_set) -> {
+      // Get mutation root type from schema
+      case schema.get_mutation_type(graphql_schema) {
+        option.Some(mutation_type) ->
+          execute_selection_set(
+            selection_set,
+            mutation_type,
+            graphql_schema,
+            ctx,
+            fragments,
+            [],
+          )
+        option.None -> Error("Schema does not define a mutation type")
+      }
+    }
+    parser.NamedMutation(_, _, selection_set) -> {
+      // Get mutation root type from schema
+      case schema.get_mutation_type(graphql_schema) {
+        option.Some(mutation_type) ->
+          execute_selection_set(
+            selection_set,
+            mutation_type,
+            graphql_schema,
+            ctx,
+            fragments,
+            [],
+          )
+        option.None -> Error("Schema does not define a mutation type")
+      }
+    }
+    parser.Subscription(selection_set) -> {
+      // Get subscription root type from schema
+      case schema.get_subscription_type(graphql_schema) {
+        option.Some(subscription_type) ->
+          execute_selection_set(
+            selection_set,
+            subscription_type,
+            graphql_schema,
+            ctx,
+            fragments,
+            [],
+          )
+        option.None -> Error("Schema does not define a subscription type")
+      }
+    }
+    parser.NamedSubscription(_, _, selection_set) -> {
+      // Get subscription root type from schema
+      case schema.get_subscription_type(graphql_schema) {
+        option.Some(subscription_type) ->
+          execute_selection_set(
+            selection_set,
+            subscription_type,
+            graphql_schema,
+            ctx,
+            fragments,
+            [],
+          )
+        option.None -> Error("Schema does not define a subscription type")
+      }
+    }
+    parser.FragmentDefinition(_, _, _) ->
+      Error("Fragment definitions are not executable operations")
+  }
+}
+
+/// Execute a selection set
+fn execute_selection_set(
+  selection_set: parser.SelectionSet,
+  parent_type: schema.Type,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+  fragments: Dict(String, parser.Operation),
+  path: List(String),
+) -> Result(#(value.Value, List(GraphQLError)), String) {
+  case selection_set {
+    parser.SelectionSet(selections) -> {
+      let results =
+        list.map(selections, fn(selection) {
+          execute_selection(
+            selection,
+            parent_type,
+            graphql_schema,
+            ctx,
+            fragments,
+            path,
+          )
+        })
+
+      // Collect all data and errors, merging fragment fields
+      let #(data, errors) = collect_and_merge_fields(results)
+
+      Ok(#(value.Object(data), errors))
+    }
+  }
+}
+
+/// Collect and merge fields from selection results, handling fragment fields
+fn collect_and_merge_fields(
+  results: List(Result(#(String, value.Value, List(GraphQLError)), String)),
+) -> #(List(#(String, value.Value)), List(GraphQLError)) {
+  let #(data, errors) =
+    results
+    |> list.fold(#([], []), fn(acc, r) {
+      let #(fields_acc, errors_acc) = acc
+      case r {
+        Ok(#("__fragment_fields", value.Object(fragment_fields), errs)) -> {
+          // Merge fragment fields into parent
+          #(
+            list.append(fields_acc, fragment_fields),
+            list.append(errors_acc, errs),
+          )
+        }
+        Ok(#("__fragment_skip", _, _errs)) -> {
+          // Skip fragment that didn't match type condition
+          acc
+        }
+        Ok(#(name, val, errs)) -> {
+          // Regular field
+          #(
+            list.append(fields_acc, [#(name, val)]),
+            list.append(errors_acc, errs),
+          )
+        }
+        Error(_) -> acc
+      }
+    })
+
+  #(data, errors)
+}
+
+/// Execute a selection
+fn execute_selection(
+  selection: parser.Selection,
+  parent_type: schema.Type,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+  fragments: Dict(String, parser.Operation),
+  path: List(String),
+) -> Result(#(String, value.Value, List(GraphQLError)), String) {
+  case selection {
+    parser.FragmentSpread(name) -> {
+      // Look up the fragment definition
+      case dict.get(fragments, name) {
+        Error(_) -> Error("Fragment '" <> name <> "' not found")
+        Ok(parser.FragmentDefinition(
+          _fname,
+          type_condition,
+          fragment_selection_set,
+        )) -> {
+          // Check type condition
+          let current_type_name = schema.type_name(parent_type)
+          case type_condition == current_type_name {
+            False -> {
+              // Type condition doesn't match, skip this fragment
+              // Return empty object as a placeholder that will be filtered out
+              Ok(#("__fragment_skip", value.Null, []))
+            }
+            True -> {
+              // Type condition matches, execute fragment's selections
+              case
+                execute_selection_set(
+                  fragment_selection_set,
+                  parent_type,
+                  graphql_schema,
+                  ctx,
+                  fragments,
+                  path,
+                )
+              {
+                Ok(#(value.Object(fields), errs)) -> {
+                  // Fragment selections should be merged into parent
+                  // For now, return as a special marker
+                  Ok(#("__fragment_fields", value.Object(fields), errs))
+                }
+                Ok(#(val, errs)) -> Ok(#("__fragment_fields", val, errs))
+                Error(err) -> Error(err)
+              }
+            }
+          }
+        }
+        Ok(_) -> Error("Invalid fragment definition")
+      }
+    }
+    parser.InlineFragment(type_condition_opt, inline_selections) -> {
+      // Check type condition if present
+      let current_type_name = schema.type_name(parent_type)
+      let should_execute = case type_condition_opt {
+        None -> True
+        Some(type_condition) -> type_condition == current_type_name
+      }
+
+      case should_execute {
+        False -> Ok(#("__fragment_skip", value.Null, []))
+        True -> {
+          let inline_selection_set = parser.SelectionSet(inline_selections)
+          case
+            execute_selection_set(
+              inline_selection_set,
+              parent_type,
+              graphql_schema,
+              ctx,
+              fragments,
+              path,
+            )
+          {
+            Ok(#(value.Object(fields), errs)) ->
+              Ok(#("__fragment_fields", value.Object(fields), errs))
+            Ok(#(val, errs)) -> Ok(#("__fragment_fields", val, errs))
+            Error(err) -> Error(err)
+          }
+        }
+      }
+    }
+    parser.Field(name, alias, arguments, nested_selections) -> {
+      // Convert arguments to dict (with variable resolution from context)
+      let args_dict = arguments_to_dict(arguments, ctx)
+
+      // Determine the response key (use alias if provided, otherwise field name)
+      let key = response_key(name, alias)
+
+      // Handle introspection meta-fields
+      case name {
+        "__typename" -> {
+          let type_name = schema.type_name(parent_type)
+          Ok(#(key, value.String(type_name), []))
+        }
+        "__schema" -> {
+          let schema_value = introspection.schema_introspection(graphql_schema)
+          // Handle nested selections on __schema
+          case nested_selections {
+            [] -> Ok(#(key, schema_value, []))
+            _ -> {
+              let selection_set = parser.SelectionSet(nested_selections)
+              // We don't have an actual type for __Schema, so we'll handle it specially
+              // For now, just return the schema value with nested execution
+              case
+                execute_introspection_selection_set(
+                  selection_set,
+                  schema_value,
+                  graphql_schema,
+                  ctx,
+                  fragments,
+                  ["__schema", ..path],
+                  set.new(),
+                )
+              {
+                Ok(#(nested_data, nested_errors)) ->
+                  Ok(#(key, nested_data, nested_errors))
+                Error(err) -> {
+                  let error = GraphQLError(err, ["__schema", ..path])
+                  Ok(#(key, value.Null, [error]))
+                }
+              }
+            }
+          }
+        }
+        "__type" -> {
+          // Extract the "name" argument
+          case dict.get(args_dict, "name") {
+            Ok(value.String(type_name)) -> {
+              // Look up the type in the schema
+              case
+                introspection.type_by_name_introspection(
+                  graphql_schema,
+                  type_name,
+                )
+              {
+                option.Some(type_value) -> {
+                  // Handle nested selections on __type
+                  case nested_selections {
+                    [] -> Ok(#(key, type_value, []))
+                    _ -> {
+                      let selection_set = parser.SelectionSet(nested_selections)
+                      case
+                        execute_introspection_selection_set(
+                          selection_set,
+                          type_value,
+                          graphql_schema,
+                          ctx,
+                          fragments,
+                          ["__type", ..path],
+                          set.new(),
+                        )
+                      {
+                        Ok(#(nested_data, nested_errors)) ->
+                          Ok(#(key, nested_data, nested_errors))
+                        Error(err) -> {
+                          let error = GraphQLError(err, ["__type", ..path])
+                          Ok(#(key, value.Null, [error]))
+                        }
+                      }
+                    }
+                  }
+                }
+                option.None -> {
+                  // Type not found, return null (per GraphQL spec)
+                  Ok(#(key, value.Null, []))
+                }
+              }
+            }
+            Ok(_) -> {
+              let error =
+                GraphQLError("__type argument 'name' must be a String", path)
+              Ok(#(key, value.Null, [error]))
+            }
+            Error(_) -> {
+              let error =
+                GraphQLError("__type requires a 'name' argument", path)
+              Ok(#(key, value.Null, [error]))
+            }
+          }
+        }
+        _ -> {
+          // Get field from schema
+          case schema.get_field(parent_type, name) {
+            None -> {
+              let error = GraphQLError("Field '" <> name <> "' not found", path)
+              Ok(#(key, value.Null, [error]))
+            }
+            Some(field) -> {
+              // Get the field's type for nested selections
+              let field_type_def = schema.field_type(field)
+
+              // Create context with arguments (preserve variables from parent context)
+              let field_ctx = schema.Context(ctx.data, args_dict, ctx.variables)
+
+              // Resolve the field
+              case schema.resolve_field(field, field_ctx) {
+                Error(err) -> {
+                  let error = GraphQLError(err, [name, ..path])
+                  Ok(#(key, value.Null, [error]))
+                }
+                Ok(field_value) -> {
+                  // If there are nested selections, recurse
+                  case nested_selections {
+                    [] -> Ok(#(key, field_value, []))
+                    _ -> {
+                      // Need to resolve nested fields
+                      case field_value {
+                        value.Object(_) -> {
+                          // Check if field_type_def is a union type
+                          // If so, resolve it to the concrete type first
+                          let type_to_use = case
+                            schema.is_union(field_type_def)
+                          {
+                            True -> {
+                              // Create context with the field value for type resolution
+                              let resolve_ctx =
+                                schema.context(option.Some(field_value))
+                              case
+                                schema.resolve_union_type(
+                                  field_type_def,
+                                  resolve_ctx,
+                                )
+                              {
+                                Ok(concrete_type) -> concrete_type
+                                Error(_) -> field_type_def
+                                // Fallback to union type if resolution fails
+                              }
+                            }
+                            False -> field_type_def
+                          }
+
+                          // Execute nested selections using the resolved type
+                          // Create new context with this object's data
+                          let object_ctx =
+                            schema.context(option.Some(field_value))
+                          let selection_set =
+                            parser.SelectionSet(nested_selections)
+                          case
+                            execute_selection_set(
+                              selection_set,
+                              type_to_use,
+                              graphql_schema,
+                              object_ctx,
+                              fragments,
+                              [name, ..path],
+                            )
+                          {
+                            Ok(#(nested_data, nested_errors)) ->
+                              Ok(#(key, nested_data, nested_errors))
+                            Error(err) -> {
+                              let error = GraphQLError(err, [name, ..path])
+                              Ok(#(key, value.Null, [error]))
+                            }
+                          }
+                        }
+                        value.List(items) -> {
+                          // Handle list with nested selections
+                          // Get the inner type from the LIST wrapper, unwrapping NonNull if needed
+                          let inner_type = case
+                            schema.inner_type(field_type_def)
+                          {
+                            option.Some(t) -> {
+                              // If the result is still wrapped (NonNull), unwrap it too
+                              case schema.inner_type(t) {
+                                option.Some(unwrapped) -> unwrapped
+                                option.None -> t
+                              }
+                            }
+                            option.None -> field_type_def
+                          }
+
+                          // Execute nested selections on each item
+                          let selection_set =
+                            parser.SelectionSet(nested_selections)
+                          let results =
+                            list.map(items, fn(item) {
+                              // Check if inner_type is a union and resolve it
+                              let item_type = case schema.is_union(inner_type) {
+                                True -> {
+                                  // Create context with the item value for type resolution
+                                  let resolve_ctx =
+                                    schema.context(option.Some(item))
+                                  case
+                                    schema.resolve_union_type(
+                                      inner_type,
+                                      resolve_ctx,
+                                    )
+                                  {
+                                    Ok(concrete_type) -> concrete_type
+                                    Error(_) -> inner_type
+                                    // Fallback to union type if resolution fails
+                                  }
+                                }
+                                False -> inner_type
+                              }
+
+                              // Create context with this item's data
+                              let item_ctx = schema.context(option.Some(item))
+                              execute_selection_set(
+                                selection_set,
+                                item_type,
+                                graphql_schema,
+                                item_ctx,
+                                fragments,
+                                [name, ..path],
+                              )
+                            })
+
+                          // Collect results and errors
+                          let processed_items =
+                            results
+                            |> list.filter_map(fn(r) {
+                              case r {
+                                Ok(#(val, _)) -> Ok(val)
+                                Error(_) -> Error(Nil)
+                              }
+                            })
+
+                          let all_errors =
+                            results
+                            |> list.flat_map(fn(r) {
+                              case r {
+                                Ok(#(_, errs)) -> errs
+                                Error(_) -> []
+                              }
+                            })
+
+                          Ok(#(key, value.List(processed_items), all_errors))
+                        }
+                        _ -> Ok(#(key, field_value, []))
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Execute a selection set on an introspection value (like __schema)
+/// This directly reads fields from the value.Object rather than using resolvers
+fn execute_introspection_selection_set(
+  selection_set: parser.SelectionSet,
+  value_obj: value.Value,
+  graphql_schema: schema.Schema,
+  ctx: schema.Context,
+  fragments: Dict(String, parser.Operation),
+  path: List(String),
+  visited_types: Set(String),
+) -> Result(#(value.Value, List(GraphQLError)), String) {
+  case selection_set {
+    parser.SelectionSet(selections) -> {
+      case value_obj {
+        value.List(items) -> {
+          // For lists, execute the selection set on each item
+          let results =
+            list.map(items, fn(item) {
+              execute_introspection_selection_set(
+                selection_set,
+                item,
+                graphql_schema,
+                ctx,
+                fragments,
+                path,
+                visited_types,
+              )
+            })
+
+          // Collect the data and errors
+          let data_items =
+            results
+            |> list.filter_map(fn(r) {
+              case r {
+                Ok(#(val, _)) -> Ok(val)
+                Error(_) -> Error(Nil)
+              }
+            })
+
+          let all_errors =
+            results
+            |> list.flat_map(fn(r) {
+              case r {
+                Ok(#(_, errs)) -> errs
+                Error(_) -> []
+              }
+            })
+
+          Ok(#(value.List(data_items), all_errors))
+        }
+        value.Null -> {
+          // If the value is null, just return null regardless of selections
+          // This handles cases like mutationType and subscriptionType which are null
+          Ok(#(value.Null, []))
+        }
+        value.Object(fields) -> {
+          // CYCLE DETECTION: Extract type name from object to detect circular references
+          let type_name = case list.key_find(fields, "name") {
+            Ok(value.String(name)) -> option.Some(name)
+            _ -> option.None
+          }
+
+          // Check if we've already visited this type to prevent infinite loops
+          let is_cycle = case type_name {
+            option.Some(name) -> set.contains(visited_types, name)
+            option.None -> False
+          }
+
+          // If we detected a cycle, return a minimal object to break the loop
+          case is_cycle {
+            True -> {
+              // Return just the type name and kind to break the cycle
+              let minimal_fields = case type_name {
+                option.Some(name) -> {
+                  let kind_value = case list.key_find(fields, "kind") {
+                    Ok(kind) -> kind
+                    Error(_) -> value.Null
+                  }
+                  [#("name", value.String(name)), #("kind", kind_value)]
+                }
+                option.None -> []
+              }
+              Ok(#(value.Object(minimal_fields), []))
+            }
+            False -> {
+              // Add current type to visited set before recursing
+              let new_visited = case type_name {
+                option.Some(name) -> set.insert(visited_types, name)
+                option.None -> visited_types
+              }
+
+              // For each selection, find the corresponding field in the object
+              let results =
+                list.map(selections, fn(selection) {
+                  case selection {
+                    parser.FragmentSpread(name) -> {
+                      // Look up the fragment definition
+                      case dict.get(fragments, name) {
+                        Error(_) -> {
+                          // Fragment not found - return error
+                          let error =
+                            GraphQLError(
+                              "Fragment '" <> name <> "' not found",
+                              path,
+                            )
+                          Ok(
+                            #(
+                              "__FRAGMENT_ERROR",
+                              value.String("Fragment not found: " <> name),
+                              [error],
+                            ),
+                          )
+                        }
+                        Ok(parser.FragmentDefinition(
+                          _fname,
+                          _type_condition,
+                          fragment_selection_set,
+                        )) -> {
+                          // For introspection, we don't check type conditions - just execute the fragment
+                          // IMPORTANT: Use visited_types (not new_visited) because we're selecting from
+                          // the SAME object, not recursing into it. The current object was already added
+                          // to new_visited, but the fragment is just selecting different fields.
+                          case
+                            execute_introspection_selection_set(
+                              fragment_selection_set,
+                              value_obj,
+                              graphql_schema,
+                              ctx,
+                              fragments,
+                              path,
+                              visited_types,
+                            )
+                          {
+                            Ok(#(value.Object(fragment_fields), errs)) ->
+                              Ok(#(
+                                "__fragment_fields",
+                                value.Object(fragment_fields),
+                                errs,
+                              ))
+                            Ok(#(val, errs)) ->
+                              Ok(#("__fragment_fields", val, errs))
+                            Error(_err) -> Error(Nil)
+                          }
+                        }
+                        Ok(_) -> Error(Nil)
+                        // Invalid fragment definition
+                      }
+                    }
+                    parser.InlineFragment(
+                      _type_condition_opt,
+                      inline_selections,
+                    ) -> {
+                      // For introspection, inline fragments always execute (no type checking needed)
+                      // Execute the inline fragment's selections on this object
+                      let inline_selection_set =
+                        parser.SelectionSet(inline_selections)
+                      case
+                        execute_introspection_selection_set(
+                          inline_selection_set,
+                          value_obj,
+                          graphql_schema,
+                          ctx,
+                          fragments,
+                          path,
+                          new_visited,
+                        )
+                      {
+                        Ok(#(value.Object(fragment_fields), errs)) ->
+                          // Return fragment fields to be merged
+                          Ok(#(
+                            "__fragment_fields",
+                            value.Object(fragment_fields),
+                            errs,
+                          ))
+                        Ok(#(val, errs)) ->
+                          Ok(#("__fragment_fields", val, errs))
+                        Error(_err) -> Error(Nil)
+                      }
+                    }
+                    parser.Field(name, alias, _arguments, nested_selections) -> {
+                      // Determine the response key (use alias if provided, otherwise field name)
+                      let key = response_key(name, alias)
+
+                      // Find the field in the object
+                      case list.key_find(fields, name) {
+                        Ok(field_value) -> {
+                          // Handle nested selections
+                          case nested_selections {
+                            [] -> Ok(#(key, field_value, []))
+                            _ -> {
+                              let selection_set =
+                                parser.SelectionSet(nested_selections)
+                              case
+                                execute_introspection_selection_set(
+                                  selection_set,
+                                  field_value,
+                                  graphql_schema,
+                                  ctx,
+                                  fragments,
+                                  [name, ..path],
+                                  new_visited,
+                                )
+                              {
+                                Ok(#(nested_data, nested_errors)) ->
+                                  Ok(#(key, nested_data, nested_errors))
+                                Error(err) -> {
+                                  let error = GraphQLError(err, [name, ..path])
+                                  Ok(#(key, value.Null, [error]))
+                                }
+                              }
+                            }
+                          }
+                        }
+                        Error(_) -> {
+                          let error =
+                            GraphQLError(
+                              "Field '" <> name <> "' not found",
+                              path,
+                            )
+                          Ok(#(key, value.Null, [error]))
+                        }
+                      }
+                    }
+                  }
+                })
+
+              // Collect all data and errors, merging fragment fields
+              let #(data, errors) =
+                results
+                |> list.fold(#([], []), fn(acc, r) {
+                  let #(fields_acc, errors_acc) = acc
+                  case r {
+                    Ok(#(
+                      "__fragment_fields",
+                      value.Object(fragment_fields),
+                      errs,
+                    )) -> {
+                      // Merge fragment fields into parent
+                      #(
+                        list.append(fields_acc, fragment_fields),
+                        list.append(errors_acc, errs),
+                      )
+                    }
+                    Ok(#(name, val, errs)) -> {
+                      // Regular field
+                      #(
+                        list.append(fields_acc, [#(name, val)]),
+                        list.append(errors_acc, errs),
+                      )
+                    }
+                    Error(_) -> acc
+                  }
+                })
+
+              Ok(#(value.Object(data), errors))
+            }
+          }
+        }
+        _ ->
+          Error(
+            "Expected object, list, or null for introspection selection set",
+          )
+      }
+    }
+  }
+}
+
+/// Convert parser ArgumentValue to value.Value
+fn argument_value_to_value(
+  arg_value: parser.ArgumentValue,
+  ctx: schema.Context,
+) -> value.Value {
+  case arg_value {
+    parser.IntValue(s) -> value.String(s)
+    parser.FloatValue(s) -> value.String(s)
+    parser.StringValue(s) -> value.String(s)
+    parser.BooleanValue(b) -> value.Boolean(b)
+    parser.NullValue -> value.Null
+    parser.EnumValue(s) -> value.String(s)
+    parser.ListValue(items) ->
+      value.List(
+        list.map(items, fn(item) { argument_value_to_value(item, ctx) }),
+      )
+    parser.ObjectValue(fields) ->
+      value.Object(
+        list.map(fields, fn(pair) {
+          let #(name, val) = pair
+          #(name, argument_value_to_value(val, ctx))
+        }),
+      )
+    parser.VariableValue(name) -> {
+      // Look up variable value from context
+      case schema.get_variable(ctx, name) {
+        option.Some(val) -> val
+        option.None -> value.Null
+      }
+    }
+  }
+}
+
+/// Convert list of Arguments to a Dict of values
+fn arguments_to_dict(
+  arguments: List(parser.Argument),
+  ctx: schema.Context,
+) -> Dict(String, value.Value) {
+  list.fold(arguments, dict.new(), fn(acc, arg) {
+    case arg {
+      parser.Argument(name, arg_value) -> {
+        let value = argument_value_to_value(arg_value, ctx)
+        dict.insert(acc, name, value)
+      }
+    }
+  })
+}

src/swell/introspection.gleam

···
+/// GraphQL Introspection
+///
+/// Implements the GraphQL introspection system per the GraphQL spec.
+/// Provides __schema, __type, and __typename meta-fields.
+import gleam/dict
+import gleam/list
+import gleam/option
+import gleam/result
+import swell/schema
+import swell/value
+
+/// Build introspection value for __schema
+pub fn schema_introspection(graphql_schema: schema.Schema) -> value.Value {
+  let query_type = schema.query_type(graphql_schema)
+  let mutation_type_option = schema.get_mutation_type(graphql_schema)
+  let subscription_type_option = schema.get_subscription_type(graphql_schema)
+
+  // Build list of all types in the schema
+  let all_types = get_all_types(graphql_schema)
+
+  // Build mutation type ref if it exists
+  let mutation_type_value = case mutation_type_option {
+    option.Some(mutation_type) -> type_ref(mutation_type)
+    option.None -> value.Null
+  }
+
+  // Build subscription type ref if it exists
+  let subscription_type_value = case subscription_type_option {
+    option.Some(subscription_type) -> type_ref(subscription_type)
+    option.None -> value.Null
+  }
+
+  value.Object([
+    #("queryType", type_ref(query_type)),
+    #("mutationType", mutation_type_value),
+    #("subscriptionType", subscription_type_value),
+    #("types", value.List(all_types)),
+    #("directives", value.List([])),
+  ])
+}
+
+/// Build introspection value for __type(name: "TypeName")
+/// Returns Some(type_introspection) if the type is found, None otherwise
+pub fn type_by_name_introspection(
+  graphql_schema: schema.Schema,
+  type_name: String,
+) -> option.Option(value.Value) {
+  let all_types = get_all_schema_types(graphql_schema)
+
+  // Find the type with the matching name
+  let found_type =
+    list.find(all_types, fn(t) { schema.type_name(t) == type_name })
+
+  case found_type {
+    Ok(t) -> option.Some(type_introspection(t))
+    Error(_) -> option.None
+  }
+}
+
+/// Get all types from the schema as schema.Type values
+/// Useful for testing and documentation generation
+pub fn get_all_schema_types(graphql_schema: schema.Schema) -> List(schema.Type) {
+  let query_type = schema.query_type(graphql_schema)
+  let mutation_type_option = schema.get_mutation_type(graphql_schema)
+  let subscription_type_option = schema.get_subscription_type(graphql_schema)
+
+  // Collect all types by traversing the query type
+  let mut_collected_types = collect_types_from_type(query_type, [])
+
+  // Also collect types from mutation type if it exists
+  let mutation_collected_types = case mutation_type_option {
+    option.Some(mutation_type) ->
+      collect_types_from_type(mutation_type, mut_collected_types)
+    option.None -> mut_collected_types
+  }
+
+  // Also collect types from subscription type if it exists
+  let all_collected_types = case subscription_type_option {
+    option.Some(subscription_type) ->
+      collect_types_from_type(subscription_type, mutation_collected_types)
+    option.None -> mutation_collected_types
+  }
+
+  // Deduplicate by type name, preferring types with more fields
+  // This ensures we get the "most complete" version of each type
+  let unique_types = deduplicate_types_by_name(all_collected_types)
+
+  // Add any built-in scalars that aren't already in the list
+  let all_built_ins = [
+    schema.string_type(),
+    schema.int_type(),
+    schema.float_type(),
+    schema.boolean_type(),
+    schema.id_type(),
+  ]
+
+  let collected_names = list.map(unique_types, schema.type_name)
+  let missing_built_ins =
+    list.filter(all_built_ins, fn(built_in) {
+      let built_in_name = schema.type_name(built_in)
+      !list.contains(collected_names, built_in_name)
+    })
+
+  list.append(unique_types, missing_built_ins)
+}
+
+/// Get all types from the schema
+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)
+}
+
+/// Deduplicate types by name, keeping the version with the most fields
+/// This ensures we get the "most complete" version of each type when
+/// multiple versions exist (e.g., from different passes in schema building)
+fn deduplicate_types_by_name(types: List(schema.Type)) -> List(schema.Type) {
+  // Group types by name
+  types
+  |> list.group(schema.type_name)
+  |> dict.to_list
+  |> list.map(fn(pair) {
+    let #(_name, type_list) = pair
+    // For each group, find the type with the most content
+    type_list
+    |> list.reduce(fn(best, current) {
+      // Count content: fields for object types, enum values for enums, etc.
+      let best_content_count = get_type_content_count(best)
+      let current_content_count = get_type_content_count(current)
+
+      // Prefer the type with more content
+      case current_content_count > best_content_count {
+        True -> current
+        False -> best
+      }
+    })
+    |> result.unwrap(
+      list.first(type_list)
+      |> result.unwrap(schema.string_type()),
+    )
+  })
+}
+
+/// Get the "content count" for a type (fields, enum values, input fields, etc.)
+/// This helps us pick the most complete version of a type during deduplication
+fn get_type_content_count(t: schema.Type) -> Int {
+  // For object types, count fields
+  let field_count = list.length(schema.get_fields(t))
+
+  // For enum types, count enum values
+  let enum_value_count = list.length(schema.get_enum_values(t))
+
+  // For input object types, count input fields
+  let input_field_count = list.length(schema.get_input_fields(t))
+
+  // Return the maximum (types will only have one of these be non-zero)
+  [field_count, enum_value_count, input_field_count]
+  |> list.reduce(fn(a, b) {
+    case a > b {
+      True -> a
+      False -> b
+    }
+  })
+  |> result.unwrap(0)
+}
+
+/// Collect all types referenced in a type (recursively)
+/// Note: We collect ALL instances of each type (even duplicates by name)
+/// because we want to find the "most complete" version during deduplication
+fn collect_types_from_type(
+  t: schema.Type,
+  acc: List(schema.Type),
+) -> List(schema.Type) {
+  // Always add this type - we'll deduplicate later by choosing the version with most fields
+  let new_acc = [t, ..acc]
+
+  // To prevent infinite recursion, check if we've already traversed this exact type instance
+  // We use a simple heuristic: if this type name appears multiple times AND this specific
+  // instance has the same or fewer content than what we've seen, skip traversing its children
+  let should_traverse_children = case
+    schema.is_object(t) || schema.is_enum(t) || schema.is_union(t)
+  {
+    True -> {
+      let current_content_count = get_type_content_count(t)
+      let existing_with_same_name =
+        list.filter(acc, fn(existing) {
+          schema.type_name(existing) == schema.type_name(t)
+        })
+      let max_existing_content =
+        existing_with_same_name
+        |> list.map(get_type_content_count)
+        |> list.reduce(fn(a, b) {
+          case a > b {
+            True -> a
+            False -> b
+          }
+        })
+        |> result.unwrap(0)
+
+      // Only traverse if this instance has more content than we've seen before
+      current_content_count > max_existing_content
+    }
+    False -> True
+  }
+
+  case should_traverse_children {
+    False -> new_acc
+    True -> {
+      // Recursively collect types from fields if this is an object type
+      case schema.is_object(t) {
+        True -> {
+          let fields = schema.get_fields(t)
+          list.fold(fields, new_acc, fn(acc2, field) {
+            let field_type = schema.field_type(field)
+            let acc3 = collect_types_from_type_deep(field_type, acc2)
+
+            // Also collect types from field arguments
+            let arguments = schema.field_arguments(field)
+            list.fold(arguments, acc3, fn(acc4, arg) {
+              let arg_type = schema.argument_type(arg)
+              collect_types_from_type_deep(arg_type, acc4)
+            })
+          })
+        }
+        False -> {
+          // Check if it's a union type
+          case schema.is_union(t) {
+            True -> {
+              // Collect types from union's possible_types
+              let possible_types = schema.get_possible_types(t)
+              list.fold(possible_types, new_acc, fn(acc2, union_type) {
+                collect_types_from_type_deep(union_type, acc2)
+              })
+            }
+            False -> {
+              // Check if it's an InputObjectType
+              let input_fields = schema.get_input_fields(t)
+              case list.is_empty(input_fields) {
+                False -> {
+                  // This is an InputObjectType, collect types from its fields
+                  list.fold(input_fields, new_acc, fn(acc2, input_field) {
+                    let field_type = schema.input_field_type(input_field)
+                    collect_types_from_type_deep(field_type, acc2)
+                  })
+                }
+                True -> {
+                  // Check if it's a wrapping type (List or NonNull)
+                  case schema.inner_type(t) {
+                    option.Some(inner) ->
+                      collect_types_from_type_deep(inner, new_acc)
+                    option.None -> new_acc
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/// Helper to unwrap LIST and NON_NULL and collect the inner type
+fn collect_types_from_type_deep(
+  t: schema.Type,
+  acc: List(schema.Type),
+) -> List(schema.Type) {
+  // Check if this is a wrapping type (List or NonNull)
+  case schema.inner_type(t) {
+    option.Some(inner) -> collect_types_from_type_deep(inner, acc)
+    option.None -> collect_types_from_type(t, acc)
+  }
+}
+
+/// Build full type introspection value
+fn type_introspection(t: schema.Type) -> value.Value {
+  let kind = schema.type_kind(t)
+  let type_name = schema.type_name(t)
+
+  // Get inner type for LIST and NON_NULL
+  let of_type = case schema.inner_type(t) {
+    option.Some(inner) -> type_ref(inner)
+    option.None -> value.Null
+  }
+
+  // Determine fields based on kind
+  let fields = case kind {
+    "OBJECT" -> value.List(get_fields_for_type(t))
+    _ -> value.Null
+  }
+
+  // Determine inputFields for INPUT_OBJECT types
+  let input_fields = case kind {
+    "INPUT_OBJECT" -> value.List(get_input_fields_for_type(t))
+    _ -> value.Null
+  }
+
+  // Determine enumValues for ENUM types
+  let enum_values = case kind {
+    "ENUM" -> value.List(get_enum_values_for_type(t))
+    _ -> value.Null
+  }
+
+  // Determine possibleTypes for UNION types
+  let possible_types = case kind {
+    "UNION" -> {
+      let types = schema.get_possible_types(t)
+      value.List(list.map(types, type_ref))
+    }
+    _ -> value.Null
+  }
+
+  // Handle wrapping types (LIST/NON_NULL) differently
+  let name = case kind {
+    "LIST" -> value.Null
+    "NON_NULL" -> value.Null
+    _ -> value.String(type_name)
+  }
+
+  let description = case schema.type_description(t) {
+    "" -> value.Null
+    desc -> value.String(desc)
+  }
+
+  value.Object([
+    #("kind", value.String(kind)),
+    #("name", name),
+    #("description", description),
+    #("fields", fields),
+    #("interfaces", value.List([])),
+    #("possibleTypes", possible_types),
+    #("enumValues", enum_values),
+    #("inputFields", input_fields),
+    #("ofType", of_type),
+  ])
+}
+
+/// Get fields for a type (if it's an object type)
+fn get_fields_for_type(t: schema.Type) -> List(value.Value) {
+  let fields = schema.get_fields(t)
+
+  list.map(fields, fn(field) {
+    let field_type_val = schema.field_type(field)
+    let args = schema.field_arguments(field)
+
+    value.Object([
+      #("name", value.String(schema.field_name(field))),
+      #("description", value.String(schema.field_description(field))),
+      #("args", value.List(list.map(args, argument_introspection))),
+      #("type", type_ref(field_type_val)),
+      #("isDeprecated", value.Boolean(False)),
+      #("deprecationReason", value.Null),
+    ])
+  })
+}
+
+/// Get input fields for a type (if it's an input object type)
+fn get_input_fields_for_type(t: schema.Type) -> List(value.Value) {
+  let input_fields = schema.get_input_fields(t)
+
+  list.map(input_fields, fn(input_field) {
+    let field_type_val = schema.input_field_type(input_field)
+
+    value.Object([
+      #("name", value.String(schema.input_field_name(input_field))),
+      #(
+        "description",
+        value.String(schema.input_field_description(input_field)),
+      ),
+      #("type", type_ref(field_type_val)),
+      #("defaultValue", value.Null),
+    ])
+  })
+}
+
+/// Get enum values for a type (if it's an enum type)
+fn get_enum_values_for_type(t: schema.Type) -> List(value.Value) {
+  let enum_values = schema.get_enum_values(t)
+
+  list.map(enum_values, fn(enum_value) {
+    value.Object([
+      #("name", value.String(schema.enum_value_name(enum_value))),
+      #("description", value.String(schema.enum_value_description(enum_value))),
+      #("isDeprecated", value.Boolean(False)),
+      #("deprecationReason", value.Null),
+    ])
+  })
+}
+
+/// Build introspection for an argument
+fn argument_introspection(arg: schema.Argument) -> value.Value {
+  value.Object([
+    #("name", value.String(schema.argument_name(arg))),
+    #("description", value.String(schema.argument_description(arg))),
+    #("type", type_ref(schema.argument_type(arg))),
+    #("defaultValue", value.Null),
+  ])
+}
+
+/// Build a type reference (simplified version of type_introspection for field types)
+fn type_ref(t: schema.Type) -> value.Value {
+  let kind = schema.type_kind(t)
+  let type_name = schema.type_name(t)
+
+  // Get inner type for LIST and NON_NULL
+  let of_type = case schema.inner_type(t) {
+    option.Some(inner) -> type_ref(inner)
+    option.None -> value.Null
+  }
+
+  // Handle wrapping types (LIST/NON_NULL) differently
+  let name = case kind {
+    "LIST" -> value.Null
+    "NON_NULL" -> value.Null
+    _ -> value.String(type_name)
+  }
+
+  value.Object([
+    #("kind", value.String(kind)),
+    #("name", name),
+    #("ofType", of_type),
+  ])
+}

src/swell/lexer.gleam

···
+/// GraphQL Lexer - Tokenization
+///
+/// Per GraphQL spec Section 2 - Language
+/// Converts source text into a sequence of lexical tokens
+import gleam/list
+import gleam/result
+import gleam/string
+
+/// GraphQL token types
+pub type Token {
+  // Punctuators
+  BraceOpen
+  BraceClose
+  ParenOpen
+  ParenClose
+  BracketOpen
+  BracketClose
+  Colon
+  Comma
+  Pipe
+  Equals
+  At
+  Dollar
+  Exclamation
+  Spread
+
+  // Values
+  Name(String)
+  Int(String)
+  Float(String)
+  String(String)
+
+  // Ignored tokens (kept for optional whitespace preservation)
+  Whitespace
+  Comment(String)
+}
+
+pub type LexerError {
+  UnexpectedCharacter(String, Int)
+  UnterminatedString(Int)
+  InvalidNumber(String, Int)
+}
+
+/// Tokenize a GraphQL source string into a list of tokens
+///
+/// Filters out whitespace and comments by default
+pub fn tokenize(source: String) -> Result(List(Token), LexerError) {
+  source
+  |> string.to_graphemes
+  |> tokenize_graphemes([], 0)
+  |> result.map(filter_ignored)
+}
+
+/// Internal: Tokenize graphemes recursively
+fn tokenize_graphemes(
+  graphemes: List(String),
+  acc: List(Token),
+  pos: Int,
+) -> Result(List(Token), LexerError) {
+  case graphemes {
+    [] -> Ok(list.reverse(acc))
+
+    // Whitespace
+    [" ", ..rest] | ["\t", ..rest] | ["\n", ..rest] | ["\r", ..rest] ->
+      tokenize_graphemes(rest, [Whitespace, ..acc], pos + 1)
+
+    // Comments
+    ["#", ..rest] -> {
+      let #(comment, remaining) = take_until_newline(rest)
+      tokenize_graphemes(remaining, [Comment(comment), ..acc], pos + 1)
+    }
+
+    // Punctuators
+    ["{", ..rest] -> tokenize_graphemes(rest, [BraceOpen, ..acc], pos + 1)
+    ["}", ..rest] -> tokenize_graphemes(rest, [BraceClose, ..acc], pos + 1)
+    ["(", ..rest] -> tokenize_graphemes(rest, [ParenOpen, ..acc], pos + 1)
+    [")", ..rest] -> tokenize_graphemes(rest, [ParenClose, ..acc], pos + 1)
+    ["[", ..rest] -> tokenize_graphemes(rest, [BracketOpen, ..acc], pos + 1)
+    ["]", ..rest] -> tokenize_graphemes(rest, [BracketClose, ..acc], pos + 1)
+    [":", ..rest] -> tokenize_graphemes(rest, [Colon, ..acc], pos + 1)
+    [",", ..rest] -> tokenize_graphemes(rest, [Comma, ..acc], pos + 1)
+    ["|", ..rest] -> tokenize_graphemes(rest, [Pipe, ..acc], pos + 1)
+    ["=", ..rest] -> tokenize_graphemes(rest, [Equals, ..acc], pos + 1)
+    ["@", ..rest] -> tokenize_graphemes(rest, [At, ..acc], pos + 1)
+    ["$", ..rest] -> tokenize_graphemes(rest, [Dollar, ..acc], pos + 1)
+    ["!", ..rest] -> tokenize_graphemes(rest, [Exclamation, ..acc], pos + 1)
+
+    // Spread (...)
+    [".", ".", ".", ..rest] ->
+      tokenize_graphemes(rest, [Spread, ..acc], pos + 3)
+
+    // Strings
+    ["\"", ..rest] -> {
+      case take_string(rest, []) {
+        Ok(#(str, remaining)) ->
+          tokenize_graphemes(remaining, [String(str), ..acc], pos + 1)
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Numbers (Int or Float) - check for minus or digits
+    ["-", ..]
+    | ["0", ..]
+    | ["1", ..]
+    | ["2", ..]
+    | ["3", ..]
+    | ["4", ..]
+    | ["5", ..]
+    | ["6", ..]
+    | ["7", ..]
+    | ["8", ..]
+    | ["9", ..] -> {
+      case take_number(graphemes) {
+        Ok(#(num_str, is_float, remaining)) -> {
+          let token = case is_float {
+            True -> Float(num_str)
+            False -> Int(num_str)
+          }
+          tokenize_graphemes(remaining, [token, ..acc], pos + 1)
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Names (identifiers) - must start with letter or underscore
+    [char, ..] -> {
+      case is_name_start(char) {
+        True -> {
+          let #(name, remaining) = take_name(graphemes)
+          tokenize_graphemes(remaining, [Name(name), ..acc], pos + 1)
+        }
+        False -> Error(UnexpectedCharacter(char, pos))
+      }
+    }
+  }
+}
+
+/// Take characters until newline
+fn take_until_newline(graphemes: List(String)) -> #(String, List(String)) {
+  let #(chars, rest) = take_while(graphemes, fn(c) { c != "\n" && c != "\r" })
+  #(string.concat(chars), rest)
+}
+
+/// Take string contents (handles escapes)
+fn take_string(
+  graphemes: List(String),
+  acc: List(String),
+) -> Result(#(String, List(String)), LexerError) {
+  case graphemes {
+    [] -> Error(UnterminatedString(0))
+
+    ["\"", ..rest] -> Ok(#(string.concat(list.reverse(acc)), rest))
+
+    ["\\", "n", ..rest] -> take_string(rest, ["\n", ..acc])
+    ["\\", "r", ..rest] -> take_string(rest, ["\r", ..acc])
+    ["\\", "t", ..rest] -> take_string(rest, ["\t", ..acc])
+    ["\\", "\"", ..rest] -> take_string(rest, ["\"", ..acc])
+    ["\\", "\\", ..rest] -> take_string(rest, ["\\", ..acc])
+
+    [char, ..rest] -> take_string(rest, [char, ..acc])
+  }
+}
+
+/// Take a number (int or float)
+fn take_number(
+  graphemes: List(String),
+) -> Result(#(String, Bool, List(String)), LexerError) {
+  let #(num_chars, rest) = take_while(graphemes, is_number_char)
+  let num_str = string.concat(num_chars)
+
+  let is_float =
+    string.contains(num_str, ".")
+    || string.contains(num_str, "e")
+    || string.contains(num_str, "E")
+
+  Ok(#(num_str, is_float, rest))
+}
+
+/// Take a name (identifier)
+fn take_name(graphemes: List(String)) -> #(String, List(String)) {
+  let #(name_chars, rest) = take_while(graphemes, is_name_char)
+  #(string.concat(name_chars), rest)
+}
+
+/// Take characters while predicate is true
+fn take_while(
+  graphemes: List(String),
+  predicate: fn(String) -> Bool,
+) -> #(List(String), List(String)) {
+  do_take_while(graphemes, predicate, [])
+}
+
+fn do_take_while(
+  graphemes: List(String),
+  predicate: fn(String) -> Bool,
+  acc: List(String),
+) -> #(List(String), List(String)) {
+  case graphemes {
+    [char, ..rest] -> {
+      case predicate(char) {
+        True -> do_take_while(rest, predicate, [char, ..acc])
+        False -> #(list.reverse(acc), graphemes)
+      }
+    }
+    _ -> #(list.reverse(acc), graphemes)
+  }
+}
+
+/// Check if character can start a name
+fn is_name_start(char: String) -> Bool {
+  case char {
+    "a"
+    | "b"
+    | "c"
+    | "d"
+    | "e"
+    | "f"
+    | "g"
+    | "h"
+    | "i"
+    | "j"
+    | "k"
+    | "l"
+    | "m"
+    | "n"
+    | "o"
+    | "p"
+    | "q"
+    | "r"
+    | "s"
+    | "t"
+    | "u"
+    | "v"
+    | "w"
+    | "x"
+    | "y"
+    | "z" -> True
+    "A"
+    | "B"
+    | "C"
+    | "D"
+    | "E"
+    | "F"
+    | "G"
+    | "H"
+    | "I"
+    | "J"
+    | "K"
+    | "L"
+    | "M"
+    | "N"
+    | "O"
+    | "P"
+    | "Q"
+    | "R"
+    | "S"
+    | "T"
+    | "U"
+    | "V"
+    | "W"
+    | "X"
+    | "Y"
+    | "Z" -> True
+    "_" -> True
+    _ -> False
+  }
+}
+
+/// Check if character can be part of a name
+fn is_name_char(char: String) -> Bool {
+  is_name_start(char) || is_digit(char)
+}
+
+/// Check if character is a digit
+fn is_digit(char: String) -> Bool {
+  case char {
+    "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" -> True
+    _ -> False
+  }
+}
+
+/// Check if character can be part of a number
+fn is_number_char(char: String) -> Bool {
+  is_digit(char)
+  || char == "."
+  || char == "e"
+  || char == "E"
+  || char == "-"
+  || char == "+"
+}
+
+/// Filter out ignored tokens (whitespace and comments)
+fn filter_ignored(tokens: List(Token)) -> List(Token) {
+  list.filter(tokens, fn(token) {
+    case token {
+      Whitespace -> False
+      Comment(_) -> False
+      _ -> True
+    }
+  })
+}

src/swell/parser.gleam

···
+/// GraphQL Parser - Build AST from tokens
+///
+/// Per GraphQL spec Section 2 - Language
+/// Converts a token stream into an Abstract Syntax Tree
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import swell/lexer
+
+/// GraphQL Document (top-level)
+pub type Document {
+  Document(operations: List(Operation))
+}
+
+/// GraphQL Operation
+pub type Operation {
+  Query(SelectionSet)
+  NamedQuery(name: String, variables: List(Variable), selections: SelectionSet)
+  Mutation(SelectionSet)
+  NamedMutation(
+    name: String,
+    variables: List(Variable),
+    selections: SelectionSet,
+  )
+  Subscription(SelectionSet)
+  NamedSubscription(
+    name: String,
+    variables: List(Variable),
+    selections: SelectionSet,
+  )
+  FragmentDefinition(
+    name: String,
+    type_condition: String,
+    selections: SelectionSet,
+  )
+}
+
+/// Selection Set (list of fields)
+pub type SelectionSet {
+  SelectionSet(selections: List(Selection))
+}
+
+/// Selection (field or fragment)
+pub type Selection {
+  Field(
+    name: String,
+    alias: Option(String),
+    arguments: List(Argument),
+    selections: List(Selection),
+  )
+  FragmentSpread(name: String)
+  InlineFragment(type_condition: Option(String), selections: List(Selection))
+}
+
+/// Argument (name: value)
+pub type Argument {
+  Argument(name: String, value: ArgumentValue)
+}
+
+/// Argument value types
+pub type ArgumentValue {
+  IntValue(String)
+  FloatValue(String)
+  StringValue(String)
+  BooleanValue(Bool)
+  NullValue
+  EnumValue(String)
+  ListValue(List(ArgumentValue))
+  ObjectValue(List(#(String, ArgumentValue)))
+  VariableValue(String)
+}
+
+/// Variable definition
+pub type Variable {
+  Variable(name: String, type_: String)
+}
+
+pub type ParseError {
+  UnexpectedToken(lexer.Token, String)
+  UnexpectedEndOfInput(String)
+  LexerError(lexer.LexerError)
+}
+
+/// Parse a GraphQL query string into a Document
+pub fn parse(source: String) -> Result(Document, ParseError) {
+  source
+  |> lexer.tokenize
+  |> result.map_error(LexerError)
+  |> result.try(parse_document)
+}
+
+/// Parse tokens into a Document
+fn parse_document(tokens: List(lexer.Token)) -> Result(Document, ParseError) {
+  case tokens {
+    [] -> Error(UnexpectedEndOfInput("Expected query or operation"))
+    _ -> {
+      case parse_operations(tokens, []) {
+        Ok(#(operations, _remaining)) -> Ok(Document(operations))
+        Error(err) -> Error(err)
+      }
+    }
+  }
+}
+
+/// Parse operations (queries/mutations)
+fn parse_operations(
+  tokens: List(lexer.Token),
+  acc: List(Operation),
+) -> Result(#(List(Operation), List(lexer.Token)), ParseError) {
+  case tokens {
+    [] -> Ok(#(list.reverse(acc), []))
+
+    // Named query: "query Name(...) { ... }" or "query Name { ... }"
+    [lexer.Name("query"), lexer.Name(name), ..rest] -> {
+      // Check if there are variable definitions
+      case rest {
+        [lexer.ParenOpen, ..vars_rest] -> {
+          // Parse variable definitions
+          case parse_variable_definitions(vars_rest) {
+            Ok(#(variables, after_vars)) -> {
+              case parse_selection_set(after_vars) {
+                Ok(#(selections, remaining)) -> {
+                  let op = NamedQuery(name, variables, selections)
+                  parse_operations(remaining, [op, ..acc])
+                }
+                Error(err) -> Error(err)
+              }
+            }
+            Error(err) -> Error(err)
+          }
+        }
+        _ -> {
+          // No variables, parse selection set directly
+          case parse_selection_set(rest) {
+            Ok(#(selections, remaining)) -> {
+              let op = NamedQuery(name, [], selections)
+              parse_operations(remaining, [op, ..acc])
+            }
+            Error(err) -> Error(err)
+          }
+        }
+      }
+    }
+
+    // Named mutation: "mutation Name(...) { ... }" or "mutation Name { ... }"
+    [lexer.Name("mutation"), lexer.Name(name), ..rest] -> {
+      // Check if there are variable definitions
+      case rest {
+        [lexer.ParenOpen, ..vars_rest] -> {
+          // Parse variable definitions
+          case parse_variable_definitions(vars_rest) {
+            Ok(#(variables, after_vars)) -> {
+              case parse_selection_set(after_vars) {
+                Ok(#(selections, remaining)) -> {
+                  let op = NamedMutation(name, variables, selections)
+                  parse_operations(remaining, [op, ..acc])
+                }
+                Error(err) -> Error(err)
+              }
+            }
+            Error(err) -> Error(err)
+          }
+        }
+        _ -> {
+          // No variables, parse selection set directly
+          case parse_selection_set(rest) {
+            Ok(#(selections, remaining)) -> {
+              let op = NamedMutation(name, [], selections)
+              parse_operations(remaining, [op, ..acc])
+            }
+            Error(err) -> Error(err)
+          }
+        }
+      }
+    }
+
+    // Named subscription: "subscription Name(...) { ... }" or "subscription Name { ... }"
+    [lexer.Name("subscription"), lexer.Name(name), ..rest] -> {
+      // Check if there are variable definitions
+      case rest {
+        [lexer.ParenOpen, ..vars_rest] -> {
+          // Parse variable definitions
+          case parse_variable_definitions(vars_rest) {
+            Ok(#(variables, after_vars)) -> {
+              case parse_selection_set(after_vars) {
+                Ok(#(selections, remaining)) -> {
+                  let op = NamedSubscription(name, variables, selections)
+                  parse_operations(remaining, [op, ..acc])
+                }
+                Error(err) -> Error(err)
+              }
+            }
+            Error(err) -> Error(err)
+          }
+        }
+        _ -> {
+          // No variables, parse selection set directly
+          case parse_selection_set(rest) {
+            Ok(#(selections, remaining)) -> {
+              let op = NamedSubscription(name, [], selections)
+              parse_operations(remaining, [op, ..acc])
+            }
+            Error(err) -> Error(err)
+          }
+        }
+      }
+    }
+
+    // Anonymous query: "query { ... }"
+    [lexer.Name("query"), lexer.BraceOpen, ..] -> {
+      case parse_selection_set(list.drop(tokens, 1)) {
+        Ok(#(selections, remaining)) -> {
+          let op = Query(selections)
+          parse_operations(remaining, [op, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Anonymous mutation: "mutation { ... }"
+    [lexer.Name("mutation"), lexer.BraceOpen, ..] -> {
+      case parse_selection_set(list.drop(tokens, 1)) {
+        Ok(#(selections, remaining)) -> {
+          let op = Mutation(selections)
+          parse_operations(remaining, [op, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Anonymous subscription: "subscription { ... }"
+    [lexer.Name("subscription"), lexer.BraceOpen, ..] -> {
+      case parse_selection_set(list.drop(tokens, 1)) {
+        Ok(#(selections, remaining)) -> {
+          let op = Subscription(selections)
+          parse_operations(remaining, [op, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Fragment definition: "fragment Name on Type { ... }"
+    [
+      lexer.Name("fragment"),
+      lexer.Name(name),
+      lexer.Name("on"),
+      lexer.Name(type_condition),
+      ..rest
+    ] -> {
+      case parse_selection_set(rest) {
+        Ok(#(selections, remaining)) -> {
+          let op = FragmentDefinition(name, type_condition, selections)
+          parse_operations(remaining, [op, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Anonymous query: "{ ... }"
+    [lexer.BraceOpen, ..] -> {
+      case parse_selection_set(tokens) {
+        Ok(#(selections, remaining)) -> {
+          let op = Query(selections)
+          // Continue parsing to see if there are more operations (e.g., fragment definitions)
+          parse_operations(remaining, [op, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Any other token when we have operations means we're done
+    _ -> {
+      case acc {
+        [] ->
+          Error(UnexpectedToken(
+            list.first(tokens) |> result.unwrap(lexer.BraceClose),
+            "Expected query, mutation, subscription, fragment, or '{'",
+          ))
+        _ -> Ok(#(list.reverse(acc), tokens))
+      }
+    }
+  }
+}
+
+/// Parse selection set: { field1 field2 ... }
+fn parse_selection_set(
+  tokens: List(lexer.Token),
+) -> Result(#(SelectionSet, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BraceOpen, ..rest] -> {
+      case parse_selections(rest, []) {
+        Ok(#(selections, [lexer.BraceClose, ..remaining])) ->
+          Ok(#(SelectionSet(selections), remaining))
+        Ok(#(_, _remaining)) ->
+          Error(UnexpectedEndOfInput("Expected '}' to close selection set"))
+        Error(err) -> Error(err)
+      }
+    }
+    [token, ..] -> Error(UnexpectedToken(token, "Expected '{'"))
+    [] -> Error(UnexpectedEndOfInput("Expected '{'"))
+  }
+}
+
+/// Parse selections (fields)
+fn parse_selections(
+  tokens: List(lexer.Token),
+  acc: List(Selection),
+) -> Result(#(List(Selection), List(lexer.Token)), ParseError) {
+  case tokens {
+    // End of selection set
+    [lexer.BraceClose, ..] -> Ok(#(list.reverse(acc), tokens))
+
+    // Inline fragment: "... on Type { ... }" - Check this BEFORE fragment spread
+    [lexer.Spread, lexer.Name("on"), lexer.Name(type_condition), ..rest] -> {
+      case parse_selection_set(rest) {
+        Ok(#(SelectionSet(selections), remaining)) -> {
+          let inline = InlineFragment(Some(type_condition), selections)
+          parse_selections(remaining, [inline, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Fragment spread: "...FragmentName"
+    [lexer.Spread, lexer.Name(name), ..rest] -> {
+      let spread = FragmentSpread(name)
+      parse_selections(rest, [spread, ..acc])
+    }
+
+    // Field with alias: "alias: fieldName"
+    [lexer.Name(alias), lexer.Colon, lexer.Name(field_name), ..rest] -> {
+      case parse_field_with_alias(field_name, Some(alias), rest) {
+        Ok(#(field, remaining)) -> {
+          parse_selections(remaining, [field, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    // Field without alias
+    [lexer.Name(name), ..rest] -> {
+      case parse_field_with_alias(name, None, rest) {
+        Ok(#(field, remaining)) -> {
+          parse_selections(remaining, [field, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    [] -> Error(UnexpectedEndOfInput("Expected field or '}'"))
+    [token, ..] ->
+      Error(UnexpectedToken(token, "Expected field name or fragment"))
+  }
+}
+
+/// Parse a field with optional alias, arguments and nested selections
+fn parse_field_with_alias(
+  name: String,
+  alias: Option(String),
+  tokens: List(lexer.Token),
+) -> Result(#(Selection, List(lexer.Token)), ParseError) {
+  // Parse arguments if present
+  let #(arguments, after_args) = case tokens {
+    [lexer.ParenOpen, ..] -> {
+      case parse_arguments(tokens) {
+        Ok(result) -> result
+        Error(_err) -> #([], tokens)
+        // No arguments
+      }
+    }
+    _ -> #([], tokens)
+  }
+
+  // Parse nested selection set if present
+  case after_args {
+    [lexer.BraceOpen, ..] -> {
+      case parse_nested_selections(after_args) {
+        Ok(#(nested, remaining)) ->
+          Ok(#(Field(name, alias, arguments, nested), remaining))
+        Error(err) -> Error(err)
+      }
+    }
+    _ -> Ok(#(Field(name, alias, arguments, []), after_args))
+  }
+}
+
+/// Parse nested selections for a field
+fn parse_nested_selections(
+  tokens: List(lexer.Token),
+) -> Result(#(List(Selection), List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BraceOpen, ..rest] -> {
+      case parse_selections(rest, []) {
+        Ok(#(selections, [lexer.BraceClose, ..remaining])) ->
+          Ok(#(selections, remaining))
+        Ok(#(_, _remaining)) ->
+          Error(UnexpectedEndOfInput(
+            "Expected '}' to close nested selection set",
+          ))
+        Error(err) -> Error(err)
+      }
+    }
+    _ -> Ok(#([], tokens))
+  }
+}
+
+/// Parse arguments: (arg1: value1, arg2: value2)
+fn parse_arguments(
+  tokens: List(lexer.Token),
+) -> Result(#(List(Argument), List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.ParenOpen, ..rest] -> {
+      case parse_argument_list(rest, []) {
+        Ok(#(args, [lexer.ParenClose, ..remaining])) -> Ok(#(args, remaining))
+        Ok(#(_, _remaining)) ->
+          Error(UnexpectedEndOfInput("Expected ')' to close arguments"))
+        Error(err) -> Error(err)
+      }
+    }
+    _ -> Ok(#([], tokens))
+  }
+}
+
+/// Parse list of arguments
+fn parse_argument_list(
+  tokens: List(lexer.Token),
+  acc: List(Argument),
+) -> Result(#(List(Argument), List(lexer.Token)), ParseError) {
+  case tokens {
+    // End of arguments
+    [lexer.ParenClose, ..] -> Ok(#(list.reverse(acc), tokens))
+
+    // Argument: name: value
+    [lexer.Name(name), lexer.Colon, ..rest] -> {
+      case parse_argument_value(rest) {
+        Ok(#(value, remaining)) -> {
+          let arg = Argument(name, value)
+          // Skip optional comma
+          let after_comma = case remaining {
+            [lexer.Comma, ..r] -> r
+            _ -> remaining
+          }
+          parse_argument_list(after_comma, [arg, ..acc])
+        }
+        Error(err) -> Error(err)
+      }
+    }
+
+    [] -> Error(UnexpectedEndOfInput("Expected argument or ')'"))
+    [token, ..] -> Error(UnexpectedToken(token, "Expected argument name"))
+  }
+}
+
+/// Parse argument value
+fn parse_argument_value(
+  tokens: List(lexer.Token),
+) -> Result(#(ArgumentValue, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.Int(val), ..rest] -> Ok(#(IntValue(val), rest))
+    [lexer.Float(val), ..rest] -> Ok(#(FloatValue(val), rest))
+    [lexer.String(val), ..rest] -> Ok(#(StringValue(val), rest))
+    [lexer.Name("true"), ..rest] -> Ok(#(BooleanValue(True), rest))
+    [lexer.Name("false"), ..rest] -> Ok(#(BooleanValue(False), rest))
+    [lexer.Name("null"), ..rest] -> Ok(#(NullValue, rest))
+    [lexer.Name(name), ..rest] -> Ok(#(EnumValue(name), rest))
+    [lexer.Dollar, lexer.Name(name), ..rest] -> Ok(#(VariableValue(name), rest))
+    [lexer.BracketOpen, ..rest] -> parse_list_value(rest)
+    [lexer.BraceOpen, ..rest] -> parse_object_value(rest)
+    [] -> Error(UnexpectedEndOfInput("Expected value"))
+    [token, ..] -> Error(UnexpectedToken(token, "Expected value"))
+  }
+}
+
+/// Parse list value: [value, value, ...]
+fn parse_list_value(
+  tokens: List(lexer.Token),
+) -> Result(#(ArgumentValue, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BracketClose, ..rest] -> Ok(#(ListValue([]), rest))
+    _ -> parse_list_value_items(tokens, [])
+  }
+}
+
+/// Parse list value items recursively
+fn parse_list_value_items(
+  tokens: List(lexer.Token),
+  acc: List(ArgumentValue),
+) -> Result(#(ArgumentValue, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BracketClose, ..rest] -> Ok(#(ListValue(list.reverse(acc)), rest))
+    [lexer.Comma, ..rest] -> parse_list_value_items(rest, acc)
+    _ -> {
+      use #(value, rest) <- result.try(parse_argument_value(tokens))
+      parse_list_value_items(rest, [value, ..acc])
+    }
+  }
+}
+
+/// Parse object value: {field: value, field: value, ...}
+fn parse_object_value(
+  tokens: List(lexer.Token),
+) -> Result(#(ArgumentValue, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BraceClose, ..rest] -> Ok(#(ObjectValue([]), rest))
+    _ -> parse_object_value_fields(tokens, [])
+  }
+}
+
+/// Parse object value fields recursively
+fn parse_object_value_fields(
+  tokens: List(lexer.Token),
+  acc: List(#(String, ArgumentValue)),
+) -> Result(#(ArgumentValue, List(lexer.Token)), ParseError) {
+  case tokens {
+    [lexer.BraceClose, ..rest] -> Ok(#(ObjectValue(list.reverse(acc)), rest))
+    [lexer.Comma, ..rest] -> parse_object_value_fields(rest, acc)
+    [lexer.Name(field_name), lexer.Colon, ..rest] -> {
+      use #(value, rest2) <- result.try(parse_argument_value(rest))
+      parse_object_value_fields(rest2, [#(field_name, value), ..acc])
+    }
+    [] -> Error(UnexpectedEndOfInput("Expected field name or }"))
+    [token, ..] -> Error(UnexpectedToken(token, "Expected field name or }"))
+  }
+}
+
+/// Parse variable definitions: ($var1: Type!, $var2: Type)
+/// Returns the list of variables and remaining tokens after the closing paren
+fn parse_variable_definitions(
+  tokens: List(lexer.Token),
+) -> Result(#(List(Variable), List(lexer.Token)), ParseError) {
+  parse_variable_definitions_loop(tokens, [])
+}
+
+/// Parse variable definitions loop
+fn parse_variable_definitions_loop(
+  tokens: List(lexer.Token),
+  acc: List(Variable),
+) -> Result(#(List(Variable), List(lexer.Token)), ParseError) {
+  case tokens {
+    // End of variable definitions
+    [lexer.ParenClose, ..rest] -> Ok(#(list.reverse(acc), rest))
+
+    // Skip commas
+    [lexer.Comma, ..rest] -> parse_variable_definitions_loop(rest, acc)
+
+    // Parse a variable: $name: Type! or $name: Type
+    [lexer.Dollar, lexer.Name(var_name), lexer.Colon, ..rest] -> {
+      // Parse the type (Name or Name!)
+      case rest {
+        [lexer.Name(type_name), lexer.Exclamation, ..rest2] -> {
+          // Non-null type
+          let variable = Variable(var_name, type_name <> "!")
+          parse_variable_definitions_loop(rest2, [variable, ..acc])
+        }
+        [lexer.Name(type_name), ..rest2] -> {
+          // Nullable type
+          let variable = Variable(var_name, type_name)
+          parse_variable_definitions_loop(rest2, [variable, ..acc])
+        }
+        [] -> Error(UnexpectedEndOfInput("Expected type after :"))
+        [token, ..] -> Error(UnexpectedToken(token, "Expected type name"))
+      }
+    }
+
+    [] -> Error(UnexpectedEndOfInput("Expected variable definition or )"))
+    [token, ..] -> Error(UnexpectedToken(token, "Expected $variableName or )"))
+  }
+}

src/swell/schema.gleam

···
+/// GraphQL Schema - Type System
+///
+/// Per GraphQL spec Section 3 - Type System
+/// Defines the type system including scalars, objects, enums, etc.
+import gleam/dict.{type Dict}
+import gleam/list
+import gleam/option.{type Option, None}
+import swell/value
+
+/// Resolver context - will contain request context, data loaders, etc.
+pub type Context {
+  Context(
+    data: Option(value.Value),
+    arguments: Dict(String, value.Value),
+    variables: Dict(String, value.Value),
+  )
+}
+
+/// Helper to create a context without arguments or variables
+pub fn context(data: Option(value.Value)) -> Context {
+  Context(data, dict.new(), dict.new())
+}
+
+/// Helper to create a context with variables
+pub fn context_with_variables(
+  data: Option(value.Value),
+  variables: Dict(String, value.Value),
+) -> Context {
+  Context(data, dict.new(), variables)
+}
+
+/// Helper to get an argument value from context
+pub fn get_argument(ctx: Context, name: String) -> Option(value.Value) {
+  dict.get(ctx.arguments, name) |> option.from_result
+}
+
+/// Helper to get a variable value from context
+pub fn get_variable(ctx: Context, name: String) -> Option(value.Value) {
+  dict.get(ctx.variables, name) |> option.from_result
+}
+
+/// Field resolver function type
+pub type Resolver =
+  fn(Context) -> Result(value.Value, String)
+
+/// GraphQL Type
+pub opaque type Type {
+  ScalarType(name: String)
+  ObjectType(name: String, description: String, fields: List(Field))
+  InputObjectType(name: String, description: String, fields: List(InputField))
+  EnumType(name: String, description: String, values: List(EnumValue))
+  UnionType(
+    name: String,
+    description: String,
+    possible_types: List(Type),
+    type_resolver: fn(Context) -> Result(String, String),
+  )
+  ListType(inner_type: Type)
+  NonNullType(inner_type: Type)
+}
+
+/// GraphQL Field
+pub opaque type Field {
+  Field(
+    name: String,
+    field_type: Type,
+    description: String,
+    arguments: List(Argument),
+    resolver: Resolver,
+  )
+}
+
+/// GraphQL Argument
+pub opaque type Argument {
+  Argument(
+    name: String,
+    arg_type: Type,
+    description: String,
+    default_value: Option(value.Value),
+  )
+}
+
+/// GraphQL Input Field (for InputObject types)
+pub opaque type InputField {
+  InputField(
+    name: String,
+    field_type: Type,
+    description: String,
+    default_value: Option(value.Value),
+  )
+}
+
+/// GraphQL Enum Value
+pub opaque type EnumValue {
+  EnumValue(name: String, description: String)
+}
+
+/// GraphQL Schema
+pub opaque type Schema {
+  Schema(
+    query_type: Type,
+    mutation_type: Option(Type),
+    subscription_type: Option(Type),
+  )
+}
+
+// Built-in scalar types
+pub fn string_type() -> Type {
+  ScalarType("String")
+}
+
+pub fn int_type() -> Type {
+  ScalarType("Int")
+}
+
+pub fn float_type() -> Type {
+  ScalarType("Float")
+}
+
+pub fn boolean_type() -> Type {
+  ScalarType("Boolean")
+}
+
+pub fn id_type() -> Type {
+  ScalarType("ID")
+}
+
+// Type constructors
+pub fn object_type(
+  name: String,
+  description: String,
+  fields: List(Field),
+) -> Type {
+  ObjectType(name, description, fields)
+}
+
+pub fn enum_type(
+  name: String,
+  description: String,
+  values: List(EnumValue),
+) -> Type {
+  EnumType(name, description, values)
+}
+
+pub fn input_object_type(
+  name: String,
+  description: String,
+  fields: List(InputField),
+) -> Type {
+  InputObjectType(name, description, fields)
+}
+
+pub fn union_type(
+  name: String,
+  description: String,
+  possible_types: List(Type),
+  type_resolver: fn(Context) -> Result(String, String),
+) -> Type {
+  UnionType(name, description, possible_types, type_resolver)
+}
+
+pub fn list_type(inner_type: Type) -> Type {
+  ListType(inner_type)
+}
+
+pub fn non_null(inner_type: Type) -> Type {
+  NonNullType(inner_type)
+}
+
+// Field constructors
+pub fn field(
+  name: String,
+  field_type: Type,
+  description: String,
+  resolver: Resolver,
+) -> Field {
+  Field(name, field_type, description, [], resolver)
+}
+
+pub fn field_with_args(
+  name: String,
+  field_type: Type,
+  description: String,
+  arguments: List(Argument),
+  resolver: Resolver,
+) -> Field {
+  Field(name, field_type, description, arguments, resolver)
+}
+
+// Argument constructor
+pub fn argument(
+  name: String,
+  arg_type: Type,
+  description: String,
+  default_value: Option(value.Value),
+) -> Argument {
+  Argument(name, arg_type, description, default_value)
+}
+
+// Input field constructor
+pub fn input_field(
+  name: String,
+  field_type: Type,
+  description: String,
+  default_value: Option(value.Value),
+) -> InputField {
+  InputField(name, field_type, description, default_value)
+}
+
+// Enum value constructor
+pub fn enum_value(name: String, description: String) -> EnumValue {
+  EnumValue(name, description)
+}
+
+// Schema constructor
+pub fn schema(query_type: Type, mutation_type: Option(Type)) -> Schema {
+  Schema(query_type, mutation_type, None)
+}
+
+// Schema constructor with subscriptions
+pub fn schema_with_subscriptions(
+  query_type: Type,
+  mutation_type: Option(Type),
+  subscription_type: Option(Type),
+) -> Schema {
+  Schema(query_type, mutation_type, subscription_type)
+}
+
+// Accessors
+pub fn type_name(t: Type) -> String {
+  case t {
+    ScalarType(name) -> name
+    ObjectType(name, _, _) -> name
+    InputObjectType(name, _, _) -> name
+    EnumType(name, _, _) -> name
+    UnionType(name, _, _, _) -> name
+    ListType(inner) -> "[" <> type_name(inner) <> "]"
+    NonNullType(inner) -> type_name(inner) <> "!"
+  }
+}
+
+pub fn field_name(f: Field) -> String {
+  case f {
+    Field(name, _, _, _, _) -> name
+  }
+}
+
+pub fn query_type(s: Schema) -> Type {
+  case s {
+    Schema(query_type, _, _) -> query_type
+  }
+}
+
+pub fn get_mutation_type(s: Schema) -> Option(Type) {
+  case s {
+    Schema(_, mutation_type, _) -> mutation_type
+  }
+}
+
+pub fn get_subscription_type(s: Schema) -> Option(Type) {
+  case s {
+    Schema(_, _, subscription_type) -> subscription_type
+  }
+}
+
+pub fn is_non_null(t: Type) -> Bool {
+  case t {
+    NonNullType(_) -> True
+    _ -> False
+  }
+}
+
+pub fn is_list(t: Type) -> Bool {
+  case t {
+    ListType(_) -> True
+    _ -> False
+  }
+}
+
+pub fn is_input_object(t: Type) -> Bool {
+  case t {
+    InputObjectType(_, _, _) -> True
+    _ -> False
+  }
+}
+
+pub fn type_description(t: Type) -> String {
+  case t {
+    ObjectType(_, description, _) -> description
+    InputObjectType(_, description, _) -> description
+    EnumType(_, description, _) -> description
+    _ -> ""
+  }
+}
+
+// Field resolution helpers
+pub fn resolve_field(field: Field, ctx: Context) -> Result(value.Value, String) {
+  case field {
+    Field(_, _, _, _, resolver) -> resolver(ctx)
+  }
+}
+
+pub fn get_field(t: Type, field_name: String) -> Option(Field) {
+  case t {
+    ObjectType(_, _, fields) -> {
+      list.find(fields, fn(f) {
+        case f {
+          Field(name, _, _, _, _) -> name == field_name
+        }
+      })
+      |> option.from_result
+    }
+    NonNullType(inner) -> get_field(inner, field_name)
+    _ -> None
+  }
+}
+
+/// Get the type of a field
+pub fn field_type(field: Field) -> Type {
+  case field {
+    Field(_, ft, _, _, _) -> ft
+  }
+}
+
+/// Get all fields from an ObjectType
+pub fn get_fields(t: Type) -> List(Field) {
+  case t {
+    ObjectType(_, _, fields) -> fields
+    _ -> []
+  }
+}
+
+/// Get all input fields from an InputObjectType
+pub fn get_input_fields(t: Type) -> List(InputField) {
+  case t {
+    InputObjectType(_, _, fields) -> fields
+    _ -> []
+  }
+}
+
+/// Get field description
+pub fn field_description(field: Field) -> String {
+  case field {
+    Field(_, _, desc, _, _) -> desc
+  }
+}
+
+/// Get field arguments
+pub fn field_arguments(field: Field) -> List(Argument) {
+  case field {
+    Field(_, _, _, args, _) -> args
+  }
+}
+
+/// Get argument name
+pub fn argument_name(arg: Argument) -> String {
+  case arg {
+    Argument(name, _, _, _) -> name
+  }
+}
+
+/// Get argument type
+pub fn argument_type(arg: Argument) -> Type {
+  case arg {
+    Argument(_, arg_type, _, _) -> arg_type
+  }
+}
+
+/// Get argument description
+pub fn argument_description(arg: Argument) -> String {
+  case arg {
+    Argument(_, _, desc, _) -> desc
+  }
+}
+
+/// Get input field type
+pub fn input_field_type(input_field: InputField) -> Type {
+  case input_field {
+    InputField(_, field_type, _, _) -> field_type
+  }
+}
+
+/// Get input field name
+pub fn input_field_name(input_field: InputField) -> String {
+  case input_field {
+    InputField(name, _, _, _) -> name
+  }
+}
+
+/// Get input field description
+pub fn input_field_description(input_field: InputField) -> String {
+  case input_field {
+    InputField(_, _, desc, _) -> desc
+  }
+}
+
+/// Get all enum values from an EnumType
+pub fn get_enum_values(t: Type) -> List(EnumValue) {
+  case t {
+    EnumType(_, _, values) -> values
+    _ -> []
+  }
+}
+
+/// Get enum value name
+pub fn enum_value_name(enum_value: EnumValue) -> String {
+  case enum_value {
+    EnumValue(name, _) -> name
+  }
+}
+
+/// Get enum value description
+pub fn enum_value_description(enum_value: EnumValue) -> String {
+  case enum_value {
+    EnumValue(_, desc) -> desc
+  }
+}
+
+/// Check if type is a scalar
+pub fn is_scalar(t: Type) -> Bool {
+  case t {
+    ScalarType(_) -> True
+    _ -> False
+  }
+}
+
+/// Check if type is an object
+pub fn is_object(t: Type) -> Bool {
+  case t {
+    ObjectType(_, _, _) -> True
+    _ -> False
+  }
+}
+
+/// Check if type is an enum
+pub fn is_enum(t: Type) -> Bool {
+  case t {
+    EnumType(_, _, _) -> True
+    _ -> False
+  }
+}
+
+/// Check if type is a union
+pub fn is_union(t: Type) -> Bool {
+  case t {
+    UnionType(_, _, _, _) -> True
+    _ -> False
+  }
+}
+
+/// Get the possible types from a union
+pub fn get_possible_types(t: Type) -> List(Type) {
+  case t {
+    UnionType(_, _, possible_types, _) -> possible_types
+    _ -> []
+  }
+}
+
+/// 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 {
+    UnionType(_, _, possible_types, type_resolver) -> {
+      // Call the type resolver to get the concrete type name
+      case type_resolver(ctx) {
+        Ok(resolved_type_name) -> {
+          // Find the concrete type in possible_types
+          case
+            list.find(possible_types, fn(pt) {
+              type_name(pt) == resolved_type_name
+            })
+          {
+            Ok(concrete_type) -> Ok(concrete_type)
+            Error(_) ->
+              Error(
+                "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")
+  }
+}
+
+/// Get the inner type from a wrapping type (List or NonNull)
+pub fn inner_type(t: Type) -> option.Option(Type) {
+  case t {
+    ListType(inner) -> option.Some(inner)
+    NonNullType(inner) -> option.Some(inner)
+    _ -> option.None
+  }
+}
+
+/// Get the kind of a type as a string for introspection
+pub fn type_kind(t: Type) -> String {
+  case t {
+    ScalarType(_) -> "SCALAR"
+    ObjectType(_, _, _) -> "OBJECT"
+    InputObjectType(_, _, _) -> "INPUT_OBJECT"
+    EnumType(_, _, _) -> "ENUM"
+    UnionType(_, _, _, _) -> "UNION"
+    ListType(_) -> "LIST"
+    NonNullType(_) -> "NON_NULL"
+  }
+}

src/swell/sdl.gleam

···
+/// GraphQL SDL (Schema Definition Language) Printer
+///
+/// Generates proper SDL output from GraphQL schema types
+/// Follows the GraphQL specification for schema representation
+import gleam/list
+import gleam/option
+import gleam/string
+import swell/schema
+
+/// Print a single GraphQL type as SDL
+pub fn print_type(type_: schema.Type) -> String {
+  print_type_internal(type_, 0, False)
+}
+
+/// Print multiple GraphQL types as SDL with blank lines between them
+pub fn print_types(types: List(schema.Type)) -> String {
+  list.map(types, print_type)
+  |> string.join("\n\n")
+}
+
+// Internal function that handles indentation and inline mode
+fn print_type_internal(
+  type_: schema.Type,
+  indent_level: Int,
+  inline: Bool,
+) -> String {
+  let kind = schema.type_kind(type_)
+
+  case kind {
+    "INPUT_OBJECT" -> print_input_object(type_, indent_level, inline)
+    "OBJECT" -> print_object(type_, indent_level, inline)
+    "ENUM" -> print_enum(type_, indent_level, inline)
+    "UNION" -> print_union(type_, indent_level, inline)
+    "SCALAR" -> print_scalar(type_, indent_level, inline)
+    "LIST" -> {
+      case schema.inner_type(type_) {
+        option.Some(inner) ->
+          "[" <> print_type_internal(inner, indent_level, True) <> "]"
+        option.None -> "[Unknown]"
+      }
+    }
+    "NON_NULL" -> {
+      case schema.inner_type(type_) {
+        option.Some(inner) ->
+          print_type_internal(inner, indent_level, True) <> "!"
+        option.None -> "Unknown!"
+      }
+    }
+    _ -> schema.type_name(type_)
+  }
+}
+
+fn print_scalar(type_: schema.Type, indent_level: Int, inline: Bool) -> String {
+  case inline {
+    True -> schema.type_name(type_)
+    False -> {
+      let indent = string.repeat(" ", indent_level * 2)
+      let description = schema.type_description(type_)
+      let desc_block = case description {
+        "" -> ""
+        _ -> indent <> format_description(description) <> "\n"
+      }
+
+      desc_block <> indent <> "scalar " <> schema.type_name(type_)
+    }
+  }
+}
+
+fn print_union(type_: schema.Type, indent_level: Int, inline: Bool) -> String {
+  case inline {
+    True -> schema.type_name(type_)
+    False -> {
+      let type_name = schema.type_name(type_)
+      let indent = string.repeat(" ", indent_level * 2)
+      let description = schema.type_description(type_)
+      let desc_block = case description {
+        "" -> ""
+        _ -> indent <> format_description(description) <> "\n"
+      }
+
+      let possible_types = schema.get_possible_types(type_)
+      let type_names =
+        list.map(possible_types, fn(t) { schema.type_name(t) })
+        |> string.join(" | ")
+
+      desc_block <> indent <> "union " <> type_name <> " = " <> type_names
+    }
+  }
+}
+
+fn print_input_object(
+  type_: schema.Type,
+  indent_level: Int,
+  inline: Bool,
+) -> String {
+  case inline {
+    True -> schema.type_name(type_)
+    False -> {
+      let type_name = schema.type_name(type_)
+      let indent = string.repeat(" ", indent_level * 2)
+      let field_indent = string.repeat(" ", { indent_level + 1 } * 2)
+
+      let description = schema.type_description(type_)
+      let desc_block = case description {
+        "" -> ""
+        _ -> indent <> format_description(description) <> "\n"
+      }
+
+      let fields = schema.get_input_fields(type_)
+
+      let field_lines =
+        list.map(fields, fn(field) {
+          let field_name = schema.input_field_name(field)
+          let field_type = schema.input_field_type(field)
+          let field_desc = schema.input_field_description(field)
+          let field_type_str =
+            print_type_internal(field_type, indent_level + 1, True)
+
+          let field_desc_block = case field_desc {
+            "" -> ""
+            _ -> field_indent <> format_description(field_desc) <> "\n"
+          }
+
+          field_desc_block
+          <> field_indent
+          <> field_name
+          <> ": "
+          <> field_type_str
+        })
+
+      case list.is_empty(fields) {
+        True -> desc_block <> indent <> "input " <> type_name <> " {}"
+        False -> {
+          desc_block
+          <> indent
+          <> "input "
+          <> type_name
+          <> " {\n"
+          <> string.join(field_lines, "\n")
+          <> "\n"
+          <> indent
+          <> "}"
+        }
+      }
+    }
+  }
+}
+
+fn print_object(type_: schema.Type, indent_level: Int, inline: Bool) -> String {
+  case inline {
+    True -> schema.type_name(type_)
+    False -> {
+      let type_name = schema.type_name(type_)
+      let indent = string.repeat(" ", indent_level * 2)
+      let field_indent = string.repeat(" ", { indent_level + 1 } * 2)
+
+      let description = schema.type_description(type_)
+      let desc_block = case description {
+        "" -> ""
+        _ -> indent <> format_description(description) <> "\n"
+      }
+
+      let fields = schema.get_fields(type_)
+
+      let field_lines =
+        list.map(fields, fn(field) {
+          let field_name = schema.field_name(field)
+          let field_type = schema.field_type(field)
+          let field_desc = schema.field_description(field)
+          let field_type_str =
+            print_type_internal(field_type, indent_level + 1, True)
+
+          let field_desc_block = case field_desc {
+            "" -> ""
+            _ -> field_indent <> format_description(field_desc) <> "\n"
+          }
+
+          field_desc_block
+          <> field_indent
+          <> field_name
+          <> ": "
+          <> field_type_str
+        })
+
+      case list.is_empty(fields) {
+        True -> desc_block <> indent <> "type " <> type_name <> " {}"
+        False -> {
+          desc_block
+          <> indent
+          <> "type "
+          <> type_name
+          <> " {\n"
+          <> string.join(field_lines, "\n")
+          <> "\n"
+          <> indent
+          <> "}"
+        }
+      }
+    }
+  }
+}
+
+fn print_enum(type_: schema.Type, indent_level: Int, inline: Bool) -> String {
+  case inline {
+    True -> schema.type_name(type_)
+    False -> {
+      let type_name = schema.type_name(type_)
+      let indent = string.repeat(" ", indent_level * 2)
+      let value_indent = string.repeat(" ", { indent_level + 1 } * 2)
+
+      let description = schema.type_description(type_)
+      let desc_block = case description {
+        "" -> ""
+        _ -> indent <> format_description(description) <> "\n"
+      }
+
+      let values = schema.get_enum_values(type_)
+
+      let value_lines =
+        list.map(values, fn(value) {
+          let value_name = schema.enum_value_name(value)
+          let value_desc = schema.enum_value_description(value)
+
+          let value_desc_block = case value_desc {
+            "" -> ""
+            _ -> value_indent <> format_description(value_desc) <> "\n"
+          }
+
+          value_desc_block <> value_indent <> value_name
+        })
+
+      case list.is_empty(values) {
+        True -> desc_block <> indent <> "enum " <> type_name <> " {}"
+        False -> {
+          desc_block
+          <> indent
+          <> "enum "
+          <> type_name
+          <> " {\n"
+          <> string.join(value_lines, "\n")
+          <> "\n"
+          <> indent
+          <> "}"
+        }
+      }
+    }
+  }
+}
+
+/// Format a description as a triple-quoted string
+fn format_description(description: String) -> String {
+  case description {
+    "" -> ""
+    _ -> "\"\"\"" <> description <> "\"\"\""
+  }
+}

src/swell/value.gleam

···
+/// GraphQL Value types
+///
+/// Per GraphQL spec Section 2 - Language, values can be scalars, enums,
+/// lists, or objects. This module defines the core Value type used throughout
+/// the GraphQL implementation.
+/// A GraphQL value that can be used in queries, responses, and variables
+pub type Value {
+  /// Represents null/absence of a value
+  Null
+
+  /// Integer value (32-bit signed integer per spec)
+  Int(Int)
+
+  /// Floating point value (IEEE 754 double precision per spec)
+  Float(Float)
+
+  /// UTF-8 string value
+  String(String)
+
+  /// Boolean true or false
+  Boolean(Bool)
+
+  /// Enum value represented as a string (e.g., "ACTIVE", "PENDING")
+  Enum(String)
+
+  /// Ordered list of values
+  List(List(Value))
+
+  /// Unordered set of key-value pairs
+  /// Using list of tuples for simplicity and ordering preservation
+  Object(List(#(String, Value)))
+}

test/executor_test.gleam

···
+/// Tests for GraphQL Executor
+///
+/// Tests query execution combining parser + schema + resolvers
+import birdie
+import gleam/dict
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/string
+import gleeunit/should
+import swell/executor
+import swell/schema
+import swell/value
+
+// Helper to create a simple test schema
+fn test_schema() -> schema.Schema {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field("hello", schema.string_type(), "Hello field", fn(_ctx) {
+        Ok(value.String("world"))
+      }),
+      schema.field("number", schema.int_type(), "Number field", fn(_ctx) {
+        Ok(value.Int(42))
+      }),
+      schema.field_with_args(
+        "greet",
+        schema.string_type(),
+        "Greet someone",
+        [schema.argument("name", schema.string_type(), "Name to greet", None)],
+        fn(_ctx) { Ok(value.String("Hello, Alice!")) },
+      ),
+    ])
+
+  schema.schema(query_type, None)
+}
+
+// Nested object schema for testing
+fn nested_schema() -> schema.Schema {
+  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", [
+      schema.field("user", user_type, "Get user", fn(_ctx) {
+        Ok(
+          value.Object([
+            #("id", value.String("123")),
+            #("name", value.String("Alice")),
+          ]),
+        )
+      }),
+    ])
+
+  schema.schema(query_type, None)
+}
+
+pub fn execute_simple_query_test() {
+  let schema = test_schema()
+  let query = "{ hello }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(title: "Execute simple query", content: format_response(response))
+}
+
+pub fn execute_multiple_fields_test() {
+  let schema = test_schema()
+  let query = "{ hello number }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+}
+
+pub fn execute_nested_query_test() {
+  let schema = nested_schema()
+  let query = "{ user { id name } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+}
+
+// Helper to format response for snapshots
+fn format_response(response: executor.Response) -> String {
+  string.inspect(response)
+}
+
+pub fn execute_field_with_arguments_test() {
+  let schema = test_schema()
+  let query = "{ greet(name: \"Alice\") }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+}
+
+pub fn execute_invalid_query_returns_error_test() {
+  let schema = test_schema()
+  let query = "{ invalid }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  // Should return error since field doesn't exist
+  case result {
+    Ok(executor.Response(_, [_, ..])) -> should.be_true(True)
+    Error(_) -> should.be_true(True)
+    _ -> should.be_true(False)
+  }
+}
+
+pub fn execute_parse_error_returns_error_test() {
+  let schema = test_schema()
+  let query = "{ invalid syntax"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_error(result)
+}
+
+pub fn execute_typename_introspection_test() {
+  let schema = test_schema()
+  let query = "{ __typename }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute __typename introspection",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_typename_with_regular_fields_test() {
+  let schema = test_schema()
+  let query = "{ __typename hello }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute __typename with regular fields",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_schema_introspection_query_type_test() {
+  let schema = test_schema()
+  let query = "{ __schema { queryType { name } } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute __schema introspection",
+    content: format_response(response),
+  )
+}
+
+// Fragment execution tests
+pub fn execute_simple_fragment_spread_test() {
+  let schema = nested_schema()
+  let query =
+    "
+    fragment UserFields on User {
+      id
+      name
+    }
+
+    { user { ...UserFields } }
+    "
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute simple fragment spread",
+    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
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User 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("name", schema.string_type(), "User name", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "name") {
+              Ok(name_val) -> Ok(name_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+      schema.field("email", schema.string_type(), "User email", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "email") {
+              Ok(email_val) -> Ok(email_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+    ])
+
+  let list_type = schema.list_type(user_type)
+
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field("users", list_type, "Get all users", fn(_ctx) {
+        // Return a list of user objects
+        Ok(
+          value.List([
+            value.Object([
+              #("id", value.String("1")),
+              #("name", value.String("Alice")),
+              #("email", value.String("[e-mail]")),
+            ]),
+            value.Object([
+              #("id", value.String("2")),
+              #("name", value.String("Bob")),
+              #("email", value.String("[e-mail]")),
+            ]),
+          ]),
+        )
+      }),
+    ])
+
+  let schema = schema.schema(query_type, None)
+
+  // Query with nested field selection - only request id and name, not email
+  let query = "{ users { id name } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute list with nested selections",
+    content: format_response(response),
+  )
+}
+
+// Test that arguments are actually passed to resolvers
+pub fn execute_field_receives_string_argument_test() {
+  let query_type =
+    schema.object_type("Query", "Root", [
+      schema.field_with_args(
+        "echo",
+        schema.string_type(),
+        "Echo the input",
+        [schema.argument("message", schema.string_type(), "Message", None)],
+        fn(ctx) {
+          // Extract the argument from context
+          case schema.get_argument(ctx, "message") {
+            Some(value.String(msg)) -> Ok(value.String("Echo: " <> msg))
+            _ -> Ok(value.String("No message"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query = "{ echo(message: \"hello\") }"
+
+  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 field with string argument",
+    content: format_response(response),
+  )
+}
+
+// Test list argument
+pub fn execute_field_receives_list_argument_test() {
+  let query_type =
+    schema.object_type("Query", "Root", [
+      schema.field_with_args(
+        "sum",
+        schema.int_type(),
+        "Sum numbers",
+        [
+          schema.argument(
+            "numbers",
+            schema.list_type(schema.int_type()),
+            "Numbers",
+            None,
+          ),
+        ],
+        fn(ctx) {
+          case schema.get_argument(ctx, "numbers") {
+            Some(value.List(_items)) -> Ok(value.String("got list"))
+            _ -> Ok(value.String("no list"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query = "{ sum(numbers: [1, 2, 3]) }"
+
+  let result = executor.execute(query, test_schema, schema.context(None))
+
+  should.be_ok(result)
+  |> fn(response) {
+    case response {
+      executor.Response(
+        data: value.Object([#("sum", value.String("got list"))]),
+        errors: [],
+      ) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Test object argument (like sortBy)
+pub fn execute_field_receives_object_argument_test() {
+  let query_type =
+    schema.object_type("Query", "Root", [
+      schema.field_with_args(
+        "posts",
+        schema.list_type(schema.string_type()),
+        "Get posts",
+        [
+          schema.argument(
+            "sortBy",
+            schema.list_type(
+              schema.input_object_type("SortInput", "Sort", [
+                schema.input_field("field", schema.string_type(), "Field", None),
+                schema.input_field(
+                  "direction",
+                  schema.enum_type("Direction", "Direction", [
+                    schema.enum_value("ASC", "Ascending"),
+                    schema.enum_value("DESC", "Descending"),
+                  ]),
+                  "Direction",
+                  None,
+                ),
+              ]),
+            ),
+            "Sort order",
+            None,
+          ),
+        ],
+        fn(ctx) {
+          case schema.get_argument(ctx, "sortBy") {
+            Some(value.List([value.Object(fields), ..])) -> {
+              case dict.from_list(fields) {
+                fields_dict -> {
+                  case
+                    dict.get(fields_dict, "field"),
+                    dict.get(fields_dict, "direction")
+                  {
+                    Ok(value.String(field)), Ok(value.String(dir)) ->
+                      Ok(value.String("Sorting by " <> field <> " " <> dir))
+                    _, _ -> Ok(value.String("Invalid sort"))
+                  }
+                }
+              }
+            }
+            _ -> Ok(value.String("No sort"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query = "{ posts(sortBy: [{field: \"date\", direction: DESC}]) }"
+
+  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 field with object argument",
+    content: format_response(response),
+  )
+}
+
+// Variable resolution tests
+pub fn execute_query_with_variable_string_test() {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field_with_args(
+        "greet",
+        schema.string_type(),
+        "Greet someone",
+        [
+          schema.argument("name", schema.string_type(), "Name to greet", None),
+        ],
+        fn(ctx) {
+          case schema.get_argument(ctx, "name") {
+            Some(value.String(name)) ->
+              Ok(value.String("Hello, " <> name <> "!"))
+            _ -> Ok(value.String("Hello, stranger!"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query = "query Test($name: String!) { greet(name: $name) }"
+
+  // Create context with variables
+  let variables = dict.from_list([#("name", value.String("Alice"))])
+  let ctx = schema.context_with_variables(None, variables)
+
+  let result = executor.execute(query, test_schema, ctx)
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute query with string variable",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_query_with_variable_int_test() {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field_with_args(
+        "user",
+        schema.string_type(),
+        "Get user by ID",
+        [
+          schema.argument("id", schema.int_type(), "User ID", None),
+        ],
+        fn(ctx) {
+          case schema.get_argument(ctx, "id") {
+            Some(value.Int(id)) ->
+              Ok(value.String("User #" <> string.inspect(id)))
+            _ -> Ok(value.String("Unknown user"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query = "query GetUser($userId: Int!) { user(id: $userId) }"
+
+  // Create context with variables
+  let variables = dict.from_list([#("userId", value.Int(42))])
+  let ctx = schema.context_with_variables(None, variables)
+
+  let result = executor.execute(query, test_schema, ctx)
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute query with int variable",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_query_with_multiple_variables_test() {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field_with_args(
+        "search",
+        schema.string_type(),
+        "Search for something",
+        [
+          schema.argument("query", schema.string_type(), "Search query", None),
+          schema.argument("limit", schema.int_type(), "Max results", None),
+        ],
+        fn(ctx) {
+          case
+            schema.get_argument(ctx, "query"),
+            schema.get_argument(ctx, "limit")
+          {
+            Some(value.String(q)), Some(value.Int(l)) ->
+              Ok(value.String(
+                "Searching for '"
+                <> q
+                <> "' (limit: "
+                <> string.inspect(l)
+                <> ")",
+              ))
+            _, _ -> Ok(value.String("Invalid search"))
+          }
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+  let query =
+    "query Search($q: String!, $max: Int!) { search(query: $q, limit: $max) }"
+
+  // Create context with variables
+  let variables =
+    dict.from_list([
+      #("q", value.String("graphql")),
+      #("max", value.Int(10)),
+    ])
+  let ctx = schema.context_with_variables(None, variables)
+
+  let result = executor.execute(query, test_schema, ctx)
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute query with multiple variables",
+    content: format_response(response),
+  )
+}
+
+// Union type execution tests
+pub fn execute_union_with_inline_fragment_test() {
+  // Create object types that will be part of the union
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post 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("content", schema.string_type(), "Post content", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "content") {
+              Ok(content_val) -> Ok(content_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+    ])
+
+  let comment_type =
+    schema.object_type("Comment", "A comment", [
+      schema.field("text", schema.string_type(), "Comment text", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "text") {
+              Ok(text_val) -> Ok(text_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 search_result_union =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type, comment_type],
+      type_resolver,
+    )
+
+  // Create query type with a field returning the union
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field(
+        "search",
+        search_result_union,
+        "Search for content",
+        fn(_ctx) {
+          // Return a Post
+          Ok(
+            value.Object([
+              #("__typename", value.String("Post")),
+              #("title", value.String("GraphQL is awesome")),
+              #("content", value.String("Learn all about GraphQL...")),
+            ]),
+          )
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+
+  // Query with inline fragment
+  let query =
+    "
+    {
+      search {
+        ... on Post {
+          title
+          content
+        }
+        ... on Comment {
+          text
+        }
+      }
+    }
+    "
+
+  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 union with inline fragment",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_union_list_with_inline_fragments_test() {
+  // Create object types
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post 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)
+        }
+      }),
+    ])
+
+  let comment_type =
+    schema.object_type("Comment", "A comment", [
+      schema.field("text", schema.string_type(), "Comment text", fn(ctx) {
+        case ctx.data {
+          option.Some(value.Object(fields)) -> {
+            case list.key_find(fields, "text") {
+              Ok(text_val) -> Ok(text_val)
+              Error(_) -> Ok(value.Null)
+            }
+          }
+          _ -> Ok(value.Null)
+        }
+      }),
+    ])
+
+  // Type resolver
+  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 search_result_union =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type, comment_type],
+      type_resolver,
+    )
+
+  // Create query type with a list of unions
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field(
+        "searchAll",
+        schema.list_type(search_result_union),
+        "Search for all content",
+        fn(_ctx) {
+          // Return a list with mixed types
+          Ok(
+            value.List([
+              value.Object([
+                #("__typename", value.String("Post")),
+                #("title", value.String("First Post")),
+              ]),
+              value.Object([
+                #("__typename", value.String("Comment")),
+                #("text", value.String("Great article!")),
+              ]),
+              value.Object([
+                #("__typename", value.String("Post")),
+                #("title", value.String("Second Post")),
+              ]),
+            ]),
+          )
+        },
+      ),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+
+  // Query with inline fragments on list items
+  let query =
+    "
+    {
+      searchAll {
+        ... on Post {
+          title
+        }
+        ... on Comment {
+          text
+        }
+      }
+    }
+    "
+
+  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 union list with inline fragments",
+    content: format_response(response),
+  )
+}
+
+// Test field aliases
+pub fn execute_field_with_alias_test() {
+  let schema = test_schema()
+  let query = "{ greeting: hello }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  // Response should contain "greeting" as the key, not "hello"
+  case response.data {
+    value.Object(fields) -> {
+      case list.key_find(fields, "greeting") {
+        Ok(_) -> should.be_true(True)
+        Error(_) -> {
+          // Check if it incorrectly used "hello" instead
+          case list.key_find(fields, "hello") {
+            Ok(_) ->
+              panic as "Alias not applied - used 'hello' instead of 'greeting'"
+            Error(_) ->
+              panic as "Neither 'greeting' nor 'hello' found in response"
+          }
+        }
+      }
+    }
+    _ -> panic as "Expected object response"
+  }
+}
+
+// Test multiple aliases
+pub fn execute_multiple_fields_with_aliases_test() {
+  let schema = test_schema()
+  let query = "{ greeting: hello num: number }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute multiple fields with aliases",
+    content: format_response(response),
+  )
+}
+
+// Test mixed aliased and non-aliased fields
+pub fn execute_mixed_aliased_fields_test() {
+  let schema = test_schema()
+  let query = "{ greeting: hello number }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute mixed aliased and non-aliased fields",
+    content: format_response(response),
+  )
+}

test/introspection_test.gleam

···
+/// Tests for GraphQL Introspection
+///
+/// Comprehensive tests for introspection queries
+import gleam/list
+import gleam/option.{None}
+import gleeunit/should
+import swell/executor
+import swell/schema
+import swell/value
+
+// Helper to create a simple test schema
+fn test_schema() -> schema.Schema {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field("hello", schema.string_type(), "Hello field", fn(_ctx) {
+        Ok(value.String("world"))
+      }),
+      schema.field("number", schema.int_type(), "Number field", fn(_ctx) {
+        Ok(value.Int(42))
+      }),
+    ])
+
+  schema.schema(query_type, None)
+}
+
+/// Test: Multiple scalar fields on __schema
+/// This test verifies that all requested fields on __schema are returned
+pub fn schema_multiple_fields_test() {
+  let schema = test_schema()
+  let query =
+    "{ __schema { queryType { name } mutationType { name } subscriptionType { 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: []) -> {
+        // Check that we have __schema field
+        case list.key_find(fields, "__schema") {
+          Ok(value.Object(schema_fields)) -> {
+            // Check for all three fields
+            let has_query_type = case
+              list.key_find(schema_fields, "queryType")
+            {
+              Ok(value.Object(_)) -> True
+              _ -> False
+            }
+            let has_mutation_type = case
+              list.key_find(schema_fields, "mutationType")
+            {
+              Ok(value.Null) -> True
+              // Should be null
+              _ -> False
+            }
+            let has_subscription_type = case
+              list.key_find(schema_fields, "subscriptionType")
+            {
+              Ok(value.Null) -> True
+              // Should be null
+              _ -> False
+            }
+            has_query_type && has_mutation_type && has_subscription_type
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: types field with other fields
+/// Verifies that the types array is returned along with other fields
+pub fn schema_types_with_other_fields_test() {
+  let schema = test_schema()
+  let query = "{ __schema { queryType { name } 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)) -> {
+            // Check for both fields
+            let has_query_type = case
+              list.key_find(schema_fields, "queryType")
+            {
+              Ok(value.Object(qt_fields)) -> {
+                case list.key_find(qt_fields, "name") {
+                  Ok(value.String("Query")) -> True
+                  _ -> False
+                }
+              }
+              _ -> False
+            }
+            let has_types = case list.key_find(schema_fields, "types") {
+              Ok(value.List(types)) -> {
+                // Should have 6 types: Query + 5 scalars
+                list.length(types) == 6
+              }
+              _ -> False
+            }
+            has_query_type && has_types
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: All __schema top-level fields
+/// Verifies that a query with all possible __schema fields returns all of them
+pub fn schema_all_fields_test() {
+  let schema = test_schema()
+  let query =
+    "{ __schema { queryType { name } mutationType { name } subscriptionType { name } types { name } directives { 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)) -> {
+            // Check for all five fields
+            let field_count = list.length(schema_fields)
+            // Should have exactly 5 fields
+            field_count == 5
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Field order doesn't matter
+/// Verifies that field order in the query doesn't affect results
+pub fn schema_field_order_test() {
+  let schema = test_schema()
+  let query1 = "{ __schema { types { name } queryType { name } } }"
+  let query2 = "{ __schema { queryType { name } types { name } } }"
+
+  let result1 = executor.execute(query1, schema, schema.context(None))
+  let result2 = executor.execute(query2, schema, schema.context(None))
+
+  // Both should succeed
+  should.be_ok(result1)
+  should.be_ok(result2)
+
+  // Both should have the same fields
+  case result1, result2 {
+    Ok(executor.Response(data: value.Object(fields1), errors: [])),
+      Ok(executor.Response(data: value.Object(fields2), errors: []))
+    -> {
+      case
+        list.key_find(fields1, "__schema"),
+        list.key_find(fields2, "__schema")
+      {
+        Ok(value.Object(schema_fields1)), Ok(value.Object(schema_fields2)) -> {
+          let count1 = list.length(schema_fields1)
+          let count2 = list.length(schema_fields2)
+          // Both should have 2 fields
+          count1 == 2 && count2 == 2
+        }
+        _, _ -> False
+      }
+    }
+    _, _ -> False
+  }
+  |> should.be_true
+}
+
+/// Test: Nested introspection on types
+/// Verifies that nested field selections work correctly
+pub fn schema_types_nested_fields_test() {
+  let schema = test_schema()
+  let query = "{ __schema { types { name kind fields { 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)) -> {
+                // Check that each type has name, kind, and fields
+                list.all(types, fn(type_val) {
+                  case type_val {
+                    value.Object(type_fields) -> {
+                      let has_name = case list.key_find(type_fields, "name") {
+                        Ok(_) -> True
+                        _ -> False
+                      }
+                      let has_kind = case list.key_find(type_fields, "kind") {
+                        Ok(_) -> True
+                        _ -> False
+                      }
+                      let has_fields = case
+                        list.key_find(type_fields, "fields")
+                      {
+                        Ok(_) -> True
+                        // Can be null or list
+                        _ -> False
+                      }
+                      has_name && has_kind && has_fields
+                    }
+                    _ -> False
+                  }
+                })
+              }
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Empty nested selections on null fields
+/// Verifies that querying nested fields on null values doesn't cause errors
+pub fn schema_null_field_with_deep_nesting_test() {
+  let schema = test_schema()
+  let query = "{ __schema { mutationType { name fields { 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, "mutationType") {
+              Ok(value.Null) -> True
+              // Should be null, not error
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Inline fragments in introspection
+/// Verifies that inline fragments work correctly in introspection queries (like GraphiQL uses)
+pub fn schema_inline_fragment_test() {
+  let schema = test_schema()
+  let query = "{ __schema { types { ... on __Type { kind 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)) -> {
+                // Should have 6 types with kind and name fields
+                list.length(types) == 6
+                && list.all(types, fn(type_val) {
+                  case type_val {
+                    value.Object(type_fields) -> {
+                      let has_kind = case list.key_find(type_fields, "kind") {
+                        Ok(value.String(_)) -> True
+                        _ -> False
+                      }
+                      let has_name = case list.key_find(type_fields, "name") {
+                        Ok(value.String(_)) -> True
+                        _ -> False
+                      }
+                      has_kind && has_name
+                    }
+                    _ -> False
+                  }
+                })
+              }
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Basic __type query
+/// Verifies that __type(name: "TypeName") returns the correct type
+pub fn type_basic_query_test() {
+  let schema = test_schema()
+  let query = "{ __type(name: \"Query\") { name kind } }"
+
+  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, "__type") {
+          Ok(value.Object(type_fields)) -> {
+            // Check name and kind
+            let has_correct_name = case list.key_find(type_fields, "name") {
+              Ok(value.String("Query")) -> True
+              _ -> False
+            }
+            let has_correct_kind = case list.key_find(type_fields, "kind") {
+              Ok(value.String("OBJECT")) -> True
+              _ -> False
+            }
+            has_correct_name && has_correct_kind
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: __type query with nested fields
+/// Verifies that nested selections work correctly on __type
+pub fn type_nested_fields_test() {
+  let schema = test_schema()
+  let query =
+    "{ __type(name: \"Query\") { name kind fields { name type { name kind } } } }"
+
+  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, "__type") {
+          Ok(value.Object(type_fields)) -> {
+            // Check that fields exists and is a list
+            case list.key_find(type_fields, "fields") {
+              Ok(value.List(field_list)) -> {
+                // Should have 2 fields (hello and number)
+                list.length(field_list) == 2
+                && list.all(field_list, fn(field_val) {
+                  case field_val {
+                    value.Object(field_fields) -> {
+                      let has_name = case list.key_find(field_fields, "name") {
+                        Ok(value.String(_)) -> True
+                        _ -> False
+                      }
+                      let has_type = case list.key_find(field_fields, "type") {
+                        Ok(value.Object(_)) -> True
+                        _ -> False
+                      }
+                      has_name && has_type
+                    }
+                    _ -> False
+                  }
+                })
+              }
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: __type query for scalar types
+/// Verifies that __type works for built-in scalar types
+pub fn type_scalar_query_test() {
+  let schema = test_schema()
+  let query = "{ __type(name: \"String\") { name kind } }"
+
+  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, "__type") {
+          Ok(value.Object(type_fields)) -> {
+            // Check name and kind
+            let has_correct_name = case list.key_find(type_fields, "name") {
+              Ok(value.String("String")) -> True
+              _ -> False
+            }
+            let has_correct_kind = case list.key_find(type_fields, "kind") {
+              Ok(value.String("SCALAR")) -> True
+              _ -> False
+            }
+            has_correct_name && has_correct_kind
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: __type query for non-existent type
+/// Verifies that __type returns null for types that don't exist
+pub fn type_not_found_test() {
+  let schema = test_schema()
+  let query = "{ __type(name: \"NonExistentType\") { name kind } }"
+
+  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, "__type") {
+          Ok(value.Null) -> True
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: __type query without name argument
+/// Verifies that __type returns an error when name argument is missing
+pub fn type_missing_argument_test() {
+  let schema = test_schema()
+  let query = "{ __type { name kind } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+  |> fn(response) {
+    case response {
+      executor.Response(data: value.Object(fields), errors: errors) -> {
+        // Should have __type field as null
+        let has_null_type = case list.key_find(fields, "__type") {
+          Ok(value.Null) -> True
+          _ -> False
+        }
+        // Should have an error
+        let has_error = errors != []
+        has_null_type && has_error
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Combined __type and __schema query
+/// Verifies that __type and __schema can be queried together
+pub fn type_and_schema_combined_test() {
+  let schema = test_schema()
+  let query =
+    "{ __schema { queryType { name } } __type(name: \"String\") { name kind } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+  |> fn(response) {
+    case response {
+      executor.Response(data: value.Object(fields), errors: []) -> {
+        let has_schema = case list.key_find(fields, "__schema") {
+          Ok(value.Object(_)) -> True
+          _ -> False
+        }
+        let has_type = case list.key_find(fields, "__type") {
+          Ok(value.Object(_)) -> True
+          _ -> False
+        }
+        has_schema && has_type
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Deep introspection queries complete without hanging
+/// This test verifies that the cycle detection prevents infinite loops
+/// by successfully completing a deeply nested introspection query
+pub fn deep_introspection_test() {
+  let schema = test_schema()
+
+  // Query with deep nesting including ofType chains
+  // Without cycle detection, this could cause infinite loops
+  let query =
+    "{ __schema { types { name kind fields { name type { name kind ofType { name kind ofType { name } } } } } } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  // The key test: should complete without hanging
+  should.be_ok(result)
+  |> fn(response) {
+    case response {
+      executor.Response(data: value.Object(fields), errors: _errors) -> {
+        // Should have __schema field with types
+        case list.key_find(fields, "__schema") {
+          Ok(value.Object(schema_fields)) -> {
+            case list.key_find(schema_fields, "types") {
+              Ok(value.List(types)) -> types != []
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Fragment spreads work in introspection queries
+/// Verifies that fragment spreads like those used by GraphiQL work correctly
+pub fn introspection_fragment_spread_test() {
+  // Create a schema with an ENUM type
+  let sort_enum =
+    schema.enum_type("SortDirection", "Sort direction", [
+      schema.enum_value("ASC", "Ascending"),
+      schema.enum_value("DESC", "Descending"),
+    ])
+
+  let query_type =
+    schema.object_type("Query", "Root query", [
+      schema.field("items", schema.list_type(schema.string_type()), "", fn(_) {
+        Ok(value.List([value.String("a"), value.String("b")]))
+      }),
+      schema.field("sort", sort_enum, "", fn(_) { Ok(value.String("ASC")) }),
+    ])
+
+  let test_schema = schema.schema(query_type, None)
+
+  // Use a fragment spread like GraphiQL does
+  let query =
+    "
+    query IntrospectionQuery {
+      __schema {
+        types {
+          ...FullType
+        }
+      }
+    }
+
+    fragment FullType on __Type {
+      kind
+      name
+      enumValues(includeDeprecated: true) {
+        name
+        description
+      }
+    }
+    "
+
+  let result = executor.execute(query, test_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)) -> {
+                // Find the SortDirection enum
+                let enum_type =
+                  list.find(types, fn(t) {
+                    case t {
+                      value.Object(type_fields) -> {
+                        case list.key_find(type_fields, "name") {
+                          Ok(value.String("SortDirection")) -> True
+                          _ -> False
+                        }
+                      }
+                      _ -> False
+                    }
+                  })
+
+                case enum_type {
+                  Ok(value.Object(type_fields)) -> {
+                    // Should have kind field from fragment
+                    let has_kind = case list.key_find(type_fields, "kind") {
+                      Ok(value.String("ENUM")) -> True
+                      _ -> False
+                    }
+
+                    // Should have enumValues field from fragment
+                    let has_enum_values = case
+                      list.key_find(type_fields, "enumValues")
+                    {
+                      Ok(value.List(values)) -> list.length(values) == 2
+                      _ -> False
+                    }
+
+                    has_kind && has_enum_values
+                  }
+                  _ -> False
+                }
+              }
+              _ -> False
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+/// Test: Simple fragment on __type
+pub fn simple_type_fragment_test() {
+  let schema = test_schema()
+
+  let query =
+    "{ __type(name: \"Query\") { ...TypeFrag } } fragment TypeFrag on __Type { name kind }"
+
+  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, "__type") {
+          Ok(value.Object(type_fields)) -> {
+            // Check if we got an error about fragment not found
+            case list.key_find(type_fields, "__FRAGMENT_ERROR") {
+              Ok(value.String(msg)) -> {
+                // Fragment wasn't found
+                panic as msg
+              }
+              _ -> {
+                // No error, check if we have actual fields
+                type_fields != []
+              }
+            }
+          }
+          _ -> False
+        }
+      }
+      _ -> False
+    }
+  }
+  |> should.be_true
+}

test/lexer_test.gleam

···
+/// Tests for GraphQL Lexer (tokenization)
+///
+/// GraphQL spec Section 2 - Language
+/// Token types: Punctuator, Name, IntValue, FloatValue, StringValue
+/// Ignored: Whitespace, LineTerminator, Comment, Comma
+import gleeunit/should
+import swell/lexer.{
+  BraceClose, BraceOpen, Colon, Dollar, Exclamation, Float, Int, Name,
+  ParenClose, ParenOpen, String,
+}
+
+// Punctuator tests
+pub fn tokenize_brace_open_test() {
+  lexer.tokenize("{")
+  |> should.equal(Ok([BraceOpen]))
+}
+
+pub fn tokenize_brace_close_test() {
+  lexer.tokenize("}")
+  |> should.equal(Ok([BraceClose]))
+}
+
+pub fn tokenize_paren_open_test() {
+  lexer.tokenize("(")
+  |> should.equal(Ok([ParenOpen]))
+}
+
+pub fn tokenize_paren_close_test() {
+  lexer.tokenize(")")
+  |> should.equal(Ok([ParenClose]))
+}
+
+pub fn tokenize_colon_test() {
+  lexer.tokenize(":")
+  |> should.equal(Ok([Colon]))
+}
+
+pub fn tokenize_exclamation_test() {
+  lexer.tokenize("!")
+  |> should.equal(Ok([Exclamation]))
+}
+
+pub fn tokenize_dollar_test() {
+  lexer.tokenize("$")
+  |> should.equal(Ok([Dollar]))
+}
+
+// Name tests (identifiers)
+pub fn tokenize_simple_name_test() {
+  lexer.tokenize("query")
+  |> should.equal(Ok([Name("query")]))
+}
+
+pub fn tokenize_name_with_underscore_test() {
+  lexer.tokenize("user_name")
+  |> should.equal(Ok([Name("user_name")]))
+}
+
+pub fn tokenize_name_with_numbers_test() {
+  lexer.tokenize("field123")
+  |> should.equal(Ok([Name("field123")]))
+}
+
+// Int value tests
+pub fn tokenize_positive_int_test() {
+  lexer.tokenize("42")
+  |> should.equal(Ok([Int("42")]))
+}
+
+pub fn tokenize_negative_int_test() {
+  lexer.tokenize("-42")
+  |> should.equal(Ok([Int("-42")]))
+}
+
+pub fn tokenize_zero_test() {
+  lexer.tokenize("0")
+  |> should.equal(Ok([Int("0")]))
+}
+
+// Float value tests
+pub fn tokenize_simple_float_test() {
+  lexer.tokenize("3.14")
+  |> should.equal(Ok([Float("3.14")]))
+}
+
+pub fn tokenize_negative_float_test() {
+  lexer.tokenize("-3.14")
+  |> should.equal(Ok([Float("-3.14")]))
+}
+
+pub fn tokenize_float_with_exponent_test() {
+  lexer.tokenize("1.5e10")
+  |> should.equal(Ok([Float("1.5e10")]))
+}
+
+pub fn tokenize_float_with_negative_exponent_test() {
+  lexer.tokenize("1.5e-10")
+  |> should.equal(Ok([Float("1.5e-10")]))
+}
+
+// String value tests
+pub fn tokenize_empty_string_test() {
+  lexer.tokenize("\"\"")
+  |> should.equal(Ok([String("")]))
+}
+
+pub fn tokenize_simple_string_test() {
+  lexer.tokenize("\"hello\"")
+  |> should.equal(Ok([String("hello")]))
+}
+
+pub fn tokenize_string_with_spaces_test() {
+  lexer.tokenize("\"hello world\"")
+  |> should.equal(Ok([String("hello world")]))
+}
+
+pub fn tokenize_string_with_escape_test() {
+  lexer.tokenize("\"hello\\nworld\"")
+  |> should.equal(Ok([String("hello\nworld")]))
+}
+
+// Whitespace handling (should be filtered out by default)
+pub fn tokenize_with_spaces_test() {
+  lexer.tokenize("query  user")
+  |> should.equal(Ok([Name("query"), Name("user")]))
+}
+
+pub fn tokenize_with_tabs_test() {
+  lexer.tokenize("query\tuser")
+  |> should.equal(Ok([Name("query"), Name("user")]))
+}
+
+pub fn tokenize_with_newlines_test() {
+  lexer.tokenize("query\nuser")
+  |> should.equal(Ok([Name("query"), Name("user")]))
+}
+
+// Comment tests (should be filtered out)
+pub fn tokenize_with_comment_test() {
+  lexer.tokenize("query # this is a comment\nuser")
+  |> should.equal(Ok([Name("query"), Name("user")]))
+}
+
+// Complex query tests
+pub fn tokenize_simple_query_test() {
+  lexer.tokenize("{ user }")
+  |> should.equal(Ok([BraceOpen, Name("user"), BraceClose]))
+}
+
+pub fn tokenize_query_with_field_test() {
+  lexer.tokenize("{ user { name } }")
+  |> should.equal(
+    Ok([
+      BraceOpen,
+      Name("user"),
+      BraceOpen,
+      Name("name"),
+      BraceClose,
+      BraceClose,
+    ]),
+  )
+}
+
+pub fn tokenize_query_with_argument_test() {
+  lexer.tokenize("{ user(id: 42) }")
+  |> should.equal(
+    Ok([
+      BraceOpen,
+      Name("user"),
+      ParenOpen,
+      Name("id"),
+      Colon,
+      Int("42"),
+      ParenClose,
+      BraceClose,
+    ]),
+  )
+}
+
+pub fn tokenize_query_with_string_argument_test() {
+  lexer.tokenize("{ user(name: \"Alice\") }")
+  |> should.equal(
+    Ok([
+      BraceOpen,
+      Name("user"),
+      ParenOpen,
+      Name("name"),
+      Colon,
+      String("Alice"),
+      ParenClose,
+      BraceClose,
+    ]),
+  )
+}
+
+// Variable definition tests
+pub fn tokenize_variable_definition_test() {
+  lexer.tokenize("$name: String!")
+  |> should.equal(
+    Ok([Dollar, Name("name"), Colon, Name("String"), Exclamation]),
+  )
+}
+
+pub fn tokenize_variable_in_query_test() {
+  lexer.tokenize("query Test($id: Int!) { user }")
+  |> should.equal(
+    Ok([
+      Name("query"),
+      Name("Test"),
+      ParenOpen,
+      Dollar,
+      Name("id"),
+      Colon,
+      Name("Int"),
+      Exclamation,
+      ParenClose,
+      BraceOpen,
+      Name("user"),
+      BraceClose,
+    ]),
+  )
+}
+
+// Error cases - use a truly invalid character like backslash
+pub fn tokenize_invalid_character_test() {
+  lexer.tokenize("query \\invalid")
+  |> should.be_error()
+}
+
+pub fn tokenize_unclosed_string_test() {
+  lexer.tokenize("\"unclosed")
+  |> should.be_error()
+}

test/mutation_execution_test.gleam

···
+/// Tests for mutation execution
+import birdie
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/string
+import gleeunit
+import gleeunit/should
+import swell/executor
+import swell/schema
+import swell/value
+
+pub fn main() {
+  gleeunit.main()
+}
+
+fn format_response(response: executor.Response) -> String {
+  string.inspect(response)
+}
+
+fn test_schema_with_mutations() -> schema.Schema {
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case fields |> list.key_find("id") {
+              Ok(id) -> Ok(id)
+              Error(_) -> Ok(value.String("123"))
+            }
+          }
+          _ -> Ok(value.String("123"))
+        }
+      }),
+      schema.field("name", schema.string_type(), "User name", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case fields |> list.key_find("name") {
+              Ok(name) -> Ok(name)
+              Error(_) -> Ok(value.String("Unknown"))
+            }
+          }
+          _ -> Ok(value.String("Unknown"))
+        }
+      }),
+    ])
+
+  let query_type =
+    schema.object_type("Query", "Root query", [
+      schema.field("dummy", schema.string_type(), "Dummy field", fn(_) {
+        Ok(value.String("dummy"))
+      }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Root mutation", [
+      schema.field_with_args(
+        "createUser",
+        user_type,
+        "Create a user",
+        [schema.argument("name", schema.string_type(), "User name", None)],
+        fn(ctx) {
+          case schema.get_argument(ctx, "name") {
+            Some(value.String(name)) ->
+              Ok(
+                value.Object([
+                  #("id", value.String("123")),
+                  #("name", value.String(name)),
+                ]),
+              )
+            _ ->
+              Ok(
+                value.Object([
+                  #("id", value.String("123")),
+                  #("name", value.String("Default Name")),
+                ]),
+              )
+          }
+        },
+      ),
+      schema.field_with_args(
+        "deleteUser",
+        schema.boolean_type(),
+        "Delete a user",
+        [
+          schema.argument(
+            "id",
+            schema.non_null(schema.id_type()),
+            "User ID",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Boolean(True)) },
+      ),
+    ])
+
+  schema.schema(query_type, Some(mutation_type))
+}
+
+pub fn execute_simple_mutation_test() {
+  let schema = test_schema_with_mutations()
+  let query = "mutation { createUser(name: \"Alice\") { id name } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute simple mutation",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_named_mutation_test() {
+  let schema = test_schema_with_mutations()
+  let query = "mutation CreateUser { createUser(name: \"Bob\") { id name } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+}
+
+pub fn execute_multiple_mutations_test() {
+  let schema = test_schema_with_mutations()
+  let query =
+    "
+    mutation {
+      createUser(name: \"Alice\") { id name }
+      deleteUser(id: \"123\")
+    }
+  "
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  let response = case result {
+    Ok(r) -> r
+    Error(_) -> panic as "Execution failed"
+  }
+
+  birdie.snap(
+    title: "Execute multiple mutations",
+    content: format_response(response),
+  )
+}
+
+pub fn execute_mutation_without_argument_test() {
+  let schema = test_schema_with_mutations()
+  let query = "mutation { createUser { id name } }"
+
+  let result = executor.execute(query, schema, schema.context(None))
+
+  should.be_ok(result)
+}
+
+pub fn execute_mutation_with_context_test() {
+  let schema = test_schema_with_mutations()
+  let query = "mutation { createUser(name: \"Context User\") { id name } }"
+
+  let ctx_data =
+    value.Object([
+      #("userId", value.String("456")),
+      #("token", value.String("abc123")),
+    ])
+  let ctx = schema.context(Some(ctx_data))
+
+  let result = executor.execute(query, schema, ctx)
+
+  should.be_ok(result)
+}

test/mutation_parser_test.gleam

···
+/// Snapshot tests for mutation parsing
+import birdie
+import gleam/string
+import gleeunit
+import swell/parser
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// Helper to format AST as string for snapshots
+fn format_ast(doc: parser.Document) -> String {
+  string.inspect(doc)
+}
+
+pub fn parse_simple_anonymous_mutation_test() {
+  let query = "mutation { createUser(name: \"Alice\") { id name } }"
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(title: "Simple anonymous mutation", content: format_ast(doc))
+}
+
+pub fn parse_named_mutation_test() {
+  let query = "mutation CreateUser { createUser(name: \"Alice\") { id name } }"
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(title: "Named mutation", content: format_ast(doc))
+}
+
+pub fn parse_mutation_with_input_object_test() {
+  let query =
+    "
+    mutation {
+      createUser(input: { name: \"Alice\", email: \"[e-mail]\", age: 30 }) {
+        id
+        name
+        email
+      }
+    }
+  "
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(
+    title: "Parse mutation with input object argument",
+    content: format_ast(doc),
+  )
+}
+
+pub fn parse_multiple_mutations_test() {
+  let query =
+    "
+    mutation {
+      createUser(name: \"Alice\") { id }
+      deleteUser(id: \"123\") { success }
+    }
+  "
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(
+    title: "Multiple mutations in one operation",
+    content: format_ast(doc),
+  )
+}
+
+pub fn parse_mutation_with_nested_selections_test() {
+  let query =
+    "
+    mutation {
+      createPost(input: { title: \"Hello\" }) {
+        id
+        author {
+          id
+          name
+        }
+        tags
+      }
+    }
+  "
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(
+    title: "Mutation with nested selections",
+    content: format_ast(doc),
+  )
+}

test/mutation_sdl_test.gleam

···
+/// Snapshot tests for mutation SDL generation
+import birdie
+import gleam/option.{None}
+import gleeunit
+import swell/schema
+import swell/sdl
+import swell/value
+
+pub fn main() {
+  gleeunit.main()
+}
+
+pub fn simple_mutation_type_test() {
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.non_null(schema.id_type()), "User ID", fn(_) {
+        Ok(value.String("1"))
+      }),
+      schema.field("name", schema.string_type(), "User name", fn(_) {
+        Ok(value.String("Alice"))
+      }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Root mutation type", [
+      schema.field_with_args(
+        "createUser",
+        user_type,
+        "Create a new user",
+        [
+          schema.argument(
+            "name",
+            schema.non_null(schema.string_type()),
+            "User name",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+    ])
+
+  let serialized = sdl.print_type(mutation_type)
+
+  birdie.snap(title: "Simple mutation type", content: serialized)
+}
+
+pub fn mutation_with_input_object_test() {
+  let create_user_input =
+    schema.input_object_type("CreateUserInput", "Input for creating a user", [
+      schema.input_field(
+        "name",
+        schema.non_null(schema.string_type()),
+        "User name",
+        None,
+      ),
+      schema.input_field(
+        "email",
+        schema.non_null(schema.string_type()),
+        "Email address",
+        None,
+      ),
+      schema.input_field("age", schema.int_type(), "Age", None),
+    ])
+
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(_) { Ok(value.Null) }),
+      schema.field("name", schema.string_type(), "User name", fn(_) {
+        Ok(value.Null)
+      }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Mutations", [
+      schema.field_with_args(
+        "createUser",
+        user_type,
+        "Create a new user",
+        [
+          schema.argument(
+            "input",
+            schema.non_null(create_user_input),
+            "User data",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+    ])
+
+  let serialized =
+    sdl.print_types([create_user_input, user_type, mutation_type])
+
+  birdie.snap(title: "Mutation with input object argument", content: serialized)
+}
+
+pub fn multiple_mutations_test() {
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(_) { Ok(value.Null) }),
+    ])
+
+  let delete_response =
+    schema.object_type("DeleteResponse", "Delete response", [
+      schema.field("success", schema.boolean_type(), "Success flag", fn(_) {
+        Ok(value.Null)
+      }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Mutations", [
+      schema.field_with_args(
+        "createUser",
+        user_type,
+        "Create a user",
+        [schema.argument("name", schema.string_type(), "Name", None)],
+        fn(_) { Ok(value.Null) },
+      ),
+      schema.field_with_args(
+        "updateUser",
+        user_type,
+        "Update a user",
+        [
+          schema.argument(
+            "id",
+            schema.non_null(schema.id_type()),
+            "User ID",
+            None,
+          ),
+          schema.argument("name", schema.string_type(), "New name", None),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+      schema.field_with_args(
+        "deleteUser",
+        delete_response,
+        "Delete a user",
+        [
+          schema.argument(
+            "id",
+            schema.non_null(schema.id_type()),
+            "User ID",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+    ])
+
+  let serialized = sdl.print_type(mutation_type)
+
+  birdie.snap(
+    title: "Multiple mutations (CRUD operations)",
+    content: serialized,
+  )
+}
+
+pub fn mutation_returning_list_test() {
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(_) { Ok(value.Null) }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Mutations", [
+      schema.field_with_args(
+        "createUsers",
+        schema.list_type(user_type),
+        "Create multiple users",
+        [
+          schema.argument(
+            "names",
+            schema.list_type(schema.non_null(schema.string_type())),
+            "User names",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+    ])
+
+  let serialized = sdl.print_type(mutation_type)
+
+  birdie.snap(title: "Mutation returning list", content: serialized)
+}
+
+pub fn mutation_with_non_null_return_test() {
+  let user_type =
+    schema.object_type("User", "A user", [
+      schema.field("id", schema.id_type(), "User ID", fn(_) { Ok(value.Null) }),
+    ])
+
+  let mutation_type =
+    schema.object_type("Mutation", "Mutations", [
+      schema.field_with_args(
+        "createUser",
+        schema.non_null(user_type),
+        "Create a user (guaranteed to return)",
+        [
+          schema.argument(
+            "name",
+            schema.non_null(schema.string_type()),
+            "User name",
+            None,
+          ),
+        ],
+        fn(_) { Ok(value.Null) },
+      ),
+    ])
+
+  let serialized = sdl.print_type(mutation_type)
+
+  birdie.snap(title: "Mutation with non-null return type", content: serialized)
+}

test/parser_test.gleam

···
+/// Tests for GraphQL Parser (AST building)
+///
+/// GraphQL spec Section 2 - Language
+/// Parse tokens into Abstract Syntax Tree
+import gleam/list
+import gleam/option.{None}
+import gleeunit/should
+import swell/parser
+
+// Simple query tests
+pub fn parse_empty_query_test() {
+  "{ }"
+  |> parser.parse
+  |> should.be_ok
+}
+
+pub fn parse_anonymous_query_with_keyword_test() {
+  "query { user }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([parser.Field("user", None, [], [])])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_single_field_test() {
+  "{ user }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(name: "user", alias: None, arguments: [], selections: []),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_nested_fields_test() {
+  "{ user { name } }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [],
+            selections: [parser.Field("name", None, [], [])],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_multiple_fields_test() {
+  "{ user posts }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(name: "user", alias: None, arguments: [], selections: []),
+          parser.Field(
+            name: "posts",
+            alias: None,
+            arguments: [],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Arguments tests
+pub fn parse_field_with_int_argument_test() {
+  "{ user(id: 42) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [parser.Argument("id", parser.IntValue("42"))],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_field_with_string_argument_test() {
+  "{ user(name: \"Alice\") }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [parser.Argument("name", parser.StringValue("Alice"))],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_field_with_multiple_arguments_test() {
+  "{ user(id: 42, name: \"Alice\") }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [
+              parser.Argument("id", parser.IntValue("42")),
+              parser.Argument("name", parser.StringValue("Alice")),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Named operation tests
+pub fn parse_named_query_test() {
+  "query GetUser { user }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.NamedQuery(
+          name: "GetUser",
+          variables: [],
+          selections: parser.SelectionSet([parser.Field("user", None, [], [])]),
+        ),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Complex query test
+pub fn parse_complex_query_test() {
+  "
+  query GetUserPosts {
+    user(id: 1) {
+      name
+      posts {
+        title
+        content
+      }
+    }
+  }
+  "
+  |> parser.parse
+  |> should.be_ok
+}
+
+// Error cases
+pub fn parse_invalid_syntax_test() {
+  "{ user"
+  |> parser.parse
+  |> should.be_error
+}
+
+pub fn parse_empty_string_test() {
+  ""
+  |> parser.parse
+  |> should.be_error
+}
+
+pub fn parse_invalid_field_name_test() {
+  "{ 123 }"
+  |> parser.parse
+  |> should.be_error
+}
+
+// Fragment tests
+pub fn parse_fragment_definition_test() {
+  "
+  fragment UserFields on User {
+    id
+    name
+  }
+  { user { ...UserFields } }
+  "
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.FragmentDefinition(
+          name: "UserFields",
+          type_condition: "User",
+          selections: parser.SelectionSet([
+            parser.Field("id", None, [], []),
+            parser.Field("name", None, [], []),
+          ]),
+        ),
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [],
+            selections: [parser.FragmentSpread("UserFields")],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_fragment_single_line_test() {
+  // The multiline version works - let's try it
+  "
+  { __type(name: \"Query\") { ...TypeFrag } }
+  fragment TypeFrag on __Type { name kind }
+  "
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document(operations) -> list.length(operations) == 2
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_fragment_truly_single_line_test() {
+  // This is the problematic single-line version
+  "{ __type(name: \"Query\") { ...TypeFrag } } fragment TypeFrag on __Type { name kind }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document(operations) -> {
+        // If we only got 1 operation, the parser stopped after the query
+        case operations {
+          [parser.Query(_)] ->
+            panic as "Only got Query - fragment was not parsed"
+          _ -> list.length(operations) == 2
+        }
+      }
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_inline_fragment_test() {
+  "
+  { user { ... on User { name } } }
+  "
+  |> parser.parse
+  |> should.be_ok
+}
+
+// List value tests
+pub fn parse_empty_list_argument_test() {
+  "{ user(tags: []) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [parser.Argument("tags", parser.ListValue([]))],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_list_of_ints_test() {
+  "{ user(ids: [1, 2, 3]) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [
+              parser.Argument(
+                "ids",
+                parser.ListValue([
+                  parser.IntValue("1"),
+                  parser.IntValue("2"),
+                  parser.IntValue("3"),
+                ]),
+              ),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_list_of_strings_test() {
+  "{ user(tags: [\"foo\", \"bar\"]) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [
+              parser.Argument(
+                "tags",
+                parser.ListValue([
+                  parser.StringValue("foo"),
+                  parser.StringValue("bar"),
+                ]),
+              ),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Object value tests
+pub fn parse_empty_object_argument_test() {
+  "{ user(filter: {}) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [parser.Argument("filter", parser.ObjectValue([]))],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_object_with_fields_test() {
+  "{ user(filter: {name: \"Alice\", age: 30}) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [
+              parser.Argument(
+                "filter",
+                parser.ObjectValue([
+                  #("name", parser.StringValue("Alice")),
+                  #("age", parser.IntValue("30")),
+                ]),
+              ),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Nested structures
+pub fn parse_list_of_objects_test() {
+  "{ posts(sortBy: [{field: \"date\", direction: DESC}]) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "posts",
+            alias: None,
+            arguments: [
+              parser.Argument(
+                "sortBy",
+                parser.ListValue([
+                  parser.ObjectValue([
+                    #("field", parser.StringValue("date")),
+                    #("direction", parser.EnumValue("DESC")),
+                  ]),
+                ]),
+              ),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_object_with_nested_list_test() {
+  "{ user(filter: {tags: [\"a\", \"b\"]}) }"
+  |> parser.parse
+  |> should.be_ok
+}
+
+// Variable definition tests
+pub fn parse_query_with_one_variable_test() {
+  "query Test($name: String!) { user }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.NamedQuery(
+          name: "Test",
+          variables: [parser.Variable("name", "String!")],
+          selections: parser.SelectionSet([parser.Field("user", None, [], [])]),
+        ),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_query_with_multiple_variables_test() {
+  "query Test($name: String!, $age: Int) { user }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.NamedQuery(
+          name: "Test",
+          variables: [
+            parser.Variable("name", "String!"),
+            parser.Variable("age", "Int"),
+          ],
+          selections: parser.SelectionSet([parser.Field("user", None, [], [])]),
+        ),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_mutation_with_variables_test() {
+  "mutation CreateUser($name: String!, $email: String!) { createUser }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.NamedMutation(
+          name: "CreateUser",
+          variables: [
+            parser.Variable("name", "String!"),
+            parser.Variable("email", "String!"),
+          ],
+          selections: parser.SelectionSet([
+            parser.Field("createUser", None, [], []),
+          ]),
+        ),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_variable_value_in_argument_test() {
+  "{ user(name: $userName) }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Query(parser.SelectionSet([
+          parser.Field(
+            name: "user",
+            alias: None,
+            arguments: [
+              parser.Argument("name", parser.VariableValue("userName")),
+            ],
+            selections: [],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+// Subscription tests
+pub fn parse_anonymous_subscription_with_keyword_test() {
+  "subscription { messageAdded }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Subscription(parser.SelectionSet([
+          parser.Field("messageAdded", None, [], []),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_named_subscription_test() {
+  "subscription OnMessage { messageAdded { content } }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.NamedSubscription(
+          "OnMessage",
+          [],
+          parser.SelectionSet([
+            parser.Field(
+              name: "messageAdded",
+              alias: None,
+              arguments: [],
+              selections: [parser.Field("content", None, [], [])],
+            ),
+          ]),
+        ),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}
+
+pub fn parse_subscription_with_nested_fields_test() {
+  "subscription { postCreated { id title author { name } } }"
+  |> parser.parse
+  |> should.be_ok
+  |> fn(doc) {
+    case doc {
+      parser.Document([
+        parser.Subscription(parser.SelectionSet([
+          parser.Field(
+            name: "postCreated",
+            alias: None,
+            arguments: [],
+            selections: [
+              parser.Field("id", None, [], []),
+              parser.Field("title", None, [], []),
+              parser.Field(
+                name: "author",
+                alias: None,
+                arguments: [],
+                selections: [parser.Field("name", None, [], [])],
+              ),
+            ],
+          ),
+        ])),
+      ]) -> True
+      _ -> False
+    }
+  }
+  |> should.be_true
+}

test/schema_test.gleam

···
+/// Tests for GraphQL Schema (Type System)
+///
+/// GraphQL spec Section 3 - Type System
+/// Defines types, fields, and schema structure
+import gleam/option.{None}
+import gleeunit/should
+import swell/schema
+import swell/value
+
+// Type system tests
+pub fn create_scalar_type_test() {
+  let string_type = schema.string_type()
+  should.equal(schema.type_name(string_type), "String")
+}
+
+pub fn create_object_type_test() {
+  let user_type =
+    schema.object_type("User", "A user in the system", [
+      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"))
+      }),
+    ])
+
+  should.equal(schema.type_name(user_type), "User")
+}
+
+pub fn create_non_null_type_test() {
+  let non_null_string = schema.non_null(schema.string_type())
+  should.be_true(schema.is_non_null(non_null_string))
+}
+
+pub fn create_list_type_test() {
+  let list_of_strings = schema.list_type(schema.string_type())
+  should.be_true(schema.is_list(list_of_strings))
+}
+
+pub fn create_schema_test() {
+  let query_type =
+    schema.object_type("Query", "Root query type", [
+      schema.field("hello", schema.string_type(), "Hello field", fn(_ctx) {
+        Ok(value.String("world"))
+      }),
+    ])
+
+  let graphql_schema = schema.schema(query_type, None)
+  should.equal(schema.query_type(graphql_schema), query_type)
+}
+
+pub fn field_with_arguments_test() {
+  let user_field =
+    schema.field_with_args(
+      "user",
+      schema.string_type(),
+      "Get user by ID",
+      [schema.argument("id", schema.id_type(), "User ID", None)],
+      fn(_ctx) { Ok(value.String("Alice")) },
+    )
+
+  should.equal(schema.field_name(user_field), "user")
+}
+
+pub fn enum_type_test() {
+  let role_enum =
+    schema.enum_type("Role", "User role", [
+      schema.enum_value("ADMIN", "Administrator"),
+      schema.enum_value("USER", "Regular user"),
+    ])
+
+  should.equal(schema.type_name(role_enum), "Role")
+}
+
+pub fn scalar_types_exist_test() {
+  // Built-in scalar types
+  let _string = schema.string_type()
+  let _int = schema.int_type()
+  let _float = schema.float_type()
+  let _boolean = schema.boolean_type()
+  let _id = schema.id_type()
+
+  should.be_true(True)
+}
+
+// Union type tests
+pub fn create_union_type_test() {
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post title", fn(_ctx) {
+        Ok(value.String("Hello"))
+      }),
+    ])
+
+  let comment_type =
+    schema.object_type("Comment", "A comment", [
+      schema.field("text", schema.string_type(), "Comment text", fn(_ctx) {
+        Ok(value.String("Nice post"))
+      }),
+    ])
+
+  let type_resolver = fn(_ctx: schema.Context) -> Result(String, String) {
+    Ok("Post")
+  }
+
+  let union_type =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type, comment_type],
+      type_resolver,
+    )
+
+  should.equal(schema.type_name(union_type), "SearchResult")
+  should.be_true(schema.is_union(union_type))
+}
+
+pub fn union_possible_types_test() {
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post title", fn(_ctx) {
+        Ok(value.String("Hello"))
+      }),
+    ])
+
+  let comment_type =
+    schema.object_type("Comment", "A comment", [
+      schema.field("text", schema.string_type(), "Comment text", fn(_ctx) {
+        Ok(value.String("Nice post"))
+      }),
+    ])
+
+  let type_resolver = fn(_ctx: schema.Context) -> Result(String, String) {
+    Ok("Post")
+  }
+
+  let union_type =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type, comment_type],
+      type_resolver,
+    )
+
+  let possible_types = schema.get_possible_types(union_type)
+  should.equal(possible_types, [post_type, comment_type])
+}
+
+pub fn resolve_union_type_test() {
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post title", fn(_ctx) {
+        Ok(value.String("Hello"))
+      }),
+    ])
+
+  let comment_type =
+    schema.object_type("Comment", "A comment", [
+      schema.field("text", schema.string_type(), "Comment text", fn(_ctx) {
+        Ok(value.String("Nice post"))
+      }),
+    ])
+
+  // Type resolver that examines the __typename field in the data
+  let type_resolver = fn(ctx: schema.Context) -> Result(String, String) {
+    case ctx.data {
+      None -> Error("No data")
+      option.Some(value.Object(fields)) -> {
+        case fields {
+          [#("__typename", value.String(type_name)), ..] -> Ok(type_name)
+          _ -> Error("No __typename field")
+        }
+      }
+      _ -> Error("Data is not an object")
+    }
+  }
+
+  let union_type =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type, comment_type],
+      type_resolver,
+    )
+
+  // Create context with data that has __typename
+  let data =
+    value.Object([
+      #("__typename", value.String("Post")),
+      #("title", value.String("Test")),
+    ])
+  let ctx = schema.context(option.Some(data))
+  let result = schema.resolve_union_type(union_type, ctx)
+
+  case result {
+    Ok(resolved_type) -> should.equal(schema.type_name(resolved_type), "Post")
+    Error(_) -> should.be_true(False)
+  }
+}
+
+pub fn union_type_kind_test() {
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("title", schema.string_type(), "Post title", fn(_ctx) {
+        Ok(value.String("Hello"))
+      }),
+    ])
+
+  let type_resolver = fn(_ctx: schema.Context) -> Result(String, String) {
+    Ok("Post")
+  }
+
+  let union_type =
+    schema.union_type(
+      "SearchResult",
+      "A search result",
+      [post_type],
+      type_resolver,
+    )
+
+  should.equal(schema.type_kind(union_type), "UNION")
+}

test/sdl_test.gleam

···
+/// Snapshot tests for SDL generation
+///
+/// Verifies that GraphQL types are correctly serialized to SDL format
+import birdie
+import gleam/option.{None, Some}
+import gleeunit
+import swell/schema
+import swell/sdl
+import swell/value
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// ===== Input Object Types =====
+
+pub fn simple_input_object_test() {
+  let input_type =
+    schema.input_object_type(
+      "UserInput",
+      "Input for creating or updating a user",
+      [
+        schema.input_field("name", schema.string_type(), "User's name", None),
+        schema.input_field(
+          "email",
+          schema.non_null(schema.string_type()),
+          "User's email address",
+          None,
+        ),
+        schema.input_field("age", schema.int_type(), "User's age", None),
+      ],
+    )
+
+  let serialized = sdl.print_type(input_type)
+
+  birdie.snap(
+    title: "Simple input object with descriptions",
+    content: serialized,
+  )
+}
+
+pub fn input_object_with_default_values_test() {
+  let input_type =
+    schema.input_object_type("FilterInput", "Filter options for queries", [
+      schema.input_field(
+        "limit",
+        schema.int_type(),
+        "Maximum number of results",
+        Some(value.Int(10)),
+      ),
+      schema.input_field(
+        "offset",
+        schema.int_type(),
+        "Number of results to skip",
+        Some(value.Int(0)),
+      ),
+    ])
+
+  let serialized = sdl.print_type(input_type)
+
+  birdie.snap(title: "Input object with default values", content: serialized)
+}
+
+pub fn nested_input_types_test() {
+  let address_input =
+    schema.input_object_type("AddressInput", "Street address information", [
+      schema.input_field("street", schema.string_type(), "Street name", None),
+      schema.input_field("city", schema.string_type(), "City name", None),
+    ])
+
+  let user_input =
+    schema.input_object_type("UserInput", "User information", [
+      schema.input_field("name", schema.string_type(), "Full name", None),
+      schema.input_field("address", address_input, "Home address", None),
+    ])
+
+  let serialized = sdl.print_types([address_input, user_input])
+
+  birdie.snap(title: "Nested input types", content: serialized)
+}
+
+// ===== Object Types =====
+
+pub fn simple_object_type_test() {
+  let user_type =
+    schema.object_type("User", "A user in the system", [
+      schema.field("id", schema.non_null(schema.id_type()), "User ID", fn(_ctx) {
+        Ok(value.String("1"))
+      }),
+      schema.field("name", schema.string_type(), "User's name", fn(_ctx) {
+        Ok(value.String("Alice"))
+      }),
+      schema.field("email", schema.string_type(), "Email address", fn(_ctx) {
+        Ok(value.String("[e-mail]"))
+      }),
+    ])
+
+  let serialized = sdl.print_type(user_type)
+
+  birdie.snap(title: "Simple object type", content: serialized)
+}
+
+pub fn object_with_list_fields_test() {
+  let post_type =
+    schema.object_type("Post", "A blog post", [
+      schema.field("id", schema.id_type(), "Post ID", fn(_ctx) {
+        Ok(value.String("1"))
+      }),
+      schema.field("title", schema.string_type(), "Post title", fn(_ctx) {
+        Ok(value.String("Hello"))
+      }),
+      schema.field(
+        "tags",
+        schema.list_type(schema.non_null(schema.string_type())),
+        "Post tags",
+        fn(_ctx) { Ok(value.List([])) },
+      ),
+    ])
+
+  let serialized = sdl.print_type(post_type)
+
+  birdie.snap(title: "Object type with list fields", content: serialized)
+}
+
+// ===== Enum Types =====
+
+pub fn simple_enum_test() {
+  let status_enum =
+    schema.enum_type("Status", "Order status", [
+      schema.enum_value("PENDING", "Order is pending"),
+      schema.enum_value("PROCESSING", "Order is being processed"),
+      schema.enum_value("SHIPPED", "Order has been shipped"),
+      schema.enum_value("DELIVERED", "Order has been delivered"),
+    ])
+
+  let serialized = sdl.print_type(status_enum)
+
+  birdie.snap(title: "Simple enum type", content: serialized)
+}
+
+pub fn enum_without_descriptions_test() {
+  let color_enum =
+    schema.enum_type("Color", "", [
+      schema.enum_value("RED", ""),
+      schema.enum_value("GREEN", ""),
+      schema.enum_value("BLUE", ""),
+    ])
+
+  let serialized = sdl.print_type(color_enum)
+
+  birdie.snap(title: "Enum without descriptions", content: serialized)
+}
+
+// ===== Scalar Types =====
+
+pub fn built_in_scalars_test() {
+  let scalars = [
+    schema.string_type(),
+    schema.int_type(),
+    schema.float_type(),
+    schema.boolean_type(),
+    schema.id_type(),
+  ]
+
+  let serialized = sdl.print_types(scalars)
+
+  birdie.snap(title: "Built-in scalar types", content: serialized)
+}
+
+// ===== Complex Types =====
+
+pub fn type_with_non_null_and_list_test() {
+  let input_type =
+    schema.input_object_type("ComplexInput", "Complex type modifiers", [
+      schema.input_field(
+        "required",
+        schema.non_null(schema.string_type()),
+        "Required string",
+        None,
+      ),
+      schema.input_field(
+        "optionalList",
+        schema.list_type(schema.string_type()),
+        "Optional list of strings",
+        None,
+      ),
+      schema.input_field(
+        "requiredList",
+        schema.non_null(schema.list_type(schema.string_type())),
+        "Required list of optional strings",
+        None,
+      ),
+      schema.input_field(
+        "listOfRequired",
+        schema.list_type(schema.non_null(schema.string_type())),
+        "Optional list of required strings",
+        None,
+      ),
+      schema.input_field(
+        "requiredListOfRequired",
+        schema.non_null(schema.list_type(schema.non_null(schema.string_type()))),
+        "Required list of required strings",
+        None,
+      ),
+    ])
+
+  let serialized = sdl.print_type(input_type)
+
+  birdie.snap(
+    title: "Type with NonNull and List modifiers",
+    content: serialized,
+  )
+}
+
+// ===== Multiple Related Types =====
+
+pub fn related_types_test() {
+  let sort_direction =
+    schema.enum_type("SortDirection", "Sort direction for queries", [
+      schema.enum_value("ASC", "Ascending order"),
+      schema.enum_value("DESC", "Descending order"),
+    ])
+
+  let sort_field_enum =
+    schema.enum_type("UserSortField", "Fields to sort users by", [
+      schema.enum_value("NAME", "Sort by name"),
+      schema.enum_value("EMAIL", "Sort by email"),
+      schema.enum_value("CREATED_AT", "Sort by creation date"),
+    ])
+
+  let sort_input =
+    schema.input_object_type("SortInput", "Sort configuration", [
+      schema.input_field(
+        "field",
+        schema.non_null(sort_field_enum),
+        "Field to sort by",
+        None,
+      ),
+      schema.input_field(
+        "direction",
+        sort_direction,
+        "Sort direction",
+        Some(value.String("ASC")),
+      ),
+    ])
+
+  let serialized =
+    sdl.print_types([sort_direction, sort_field_enum, sort_input])
+
+  birdie.snap(title: "Multiple related types", content: serialized)
+}
+
+// ===== Empty Types (Edge Cases) =====
+
+pub fn empty_input_object_test() {
+  let empty_input = schema.input_object_type("EmptyInput", "An empty input", [])
+
+  let serialized = sdl.print_type(empty_input)
+
+  birdie.snap(title: "Empty input object", content: serialized)
+}
+
+pub fn empty_enum_test() {
+  let empty_enum = schema.enum_type("EmptyEnum", "An empty enum", [])
+
+  let serialized = sdl.print_type(empty_enum)
+
+  birdie.snap(title: "Empty enum", content: serialized)
+}

test/subscription_parser_test.gleam

···
+/// Snapshot tests for subscription parsing
+import birdie
+import gleam/string
+import gleeunit
+import swell/parser
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// Helper to format AST as string for snapshots
+fn format_ast(doc: parser.Document) -> String {
+  string.inspect(doc)
+}
+
+pub fn parse_simple_anonymous_subscription_test() {
+  let query = "subscription { messageAdded { content author } }"
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(title: "Simple anonymous subscription", content: format_ast(doc))
+}
+
+pub fn parse_named_subscription_test() {
+  let query = "subscription OnMessage { messageAdded { id content } }"
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(title: "Named subscription", content: format_ast(doc))
+}
+
+pub fn parse_subscription_with_nested_selections_test() {
+  let query =
+    "
+    subscription {
+      postCreated {
+        id
+        title
+        author {
+          id
+          name
+          email
+        }
+        comments {
+          content
+        }
+      }
+    }
+  "
+
+  let doc = case parser.parse(query) {
+    Ok(d) -> d
+    Error(_) -> panic as "Parse failed"
+  }
+
+  birdie.snap(
+    title: "Subscription with nested selections",
+    content: format_ast(doc),
+  )
+}

test/subscription_test.gleam

···
+import gleam/list
+import gleam/option.{None, Some}
+import gleeunit
+import gleeunit/should
+import swell/executor
+import swell/schema
+import swell/value
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// Test: Create a subscription type
+pub fn create_subscription_type_test() {
+  let subscription_field =
+    schema.field(
+      "testSubscription",
+      schema.string_type(),
+      "A test subscription",
+      fn(_ctx) { Ok(value.String("test")) },
+    )
+
+  let subscription_type =
+    schema.object_type("Subscription", "Root subscription type", [
+      subscription_field,
+    ])
+
+  schema.type_name(subscription_type)
+  |> should.equal("Subscription")
+}
+
+// Test: Schema with subscription type
+pub fn schema_with_subscription_test() {
+  let query_field =
+    schema.field("hello", schema.string_type(), "Hello query", fn(_ctx) {
+      Ok(value.String("world"))
+    })
+
+  let query_type = schema.object_type("Query", "Root query type", [query_field])
+
+  let subscription_field =
+    schema.field(
+      "messageAdded",
+      schema.string_type(),
+      "Subscribe to new messages",
+      fn(_ctx) { Ok(value.String("test message")) },
+    )
+
+  let subscription_type =
+    schema.object_type("Subscription", "Root subscription type", [
+      subscription_field,
+    ])
+
+  let test_schema =
+    schema.schema_with_subscriptions(query_type, None, Some(subscription_type))
+
+  // Schema should be created successfully
+  // We can't easily test inequality on opaque types, so just verify it doesn't crash
+  let _ = test_schema
+  should.be_true(True)
+}
+
+// Test: Get subscription fields
+pub fn get_subscription_fields_test() {
+  let subscription_field1 =
+    schema.field(
+      "postCreated",
+      schema.string_type(),
+      "New post created",
+      fn(_ctx) { Ok(value.String("post1")) },
+    )
+
+  let subscription_field2 =
+    schema.field("postUpdated", schema.string_type(), "Post updated", fn(_ctx) {
+      Ok(value.String("post1"))
+    })
+
+  let subscription_type =
+    schema.object_type("Subscription", "Root subscription type", [
+      subscription_field1,
+      subscription_field2,
+    ])
+
+  let fields = schema.get_fields(subscription_type)
+
+  list.length(fields)
+  |> should.equal(2)
+}
+
+// Test: Execute anonymous subscription
+pub fn execute_anonymous_subscription_test() {
+  let query_type =
+    schema.object_type("Query", "Root query", [
+      schema.field("dummy", schema.string_type(), "Dummy", fn(_) {
+        Ok(value.String("dummy"))
+      }),
+    ])
+
+  let message_type =
+    schema.object_type("Message", "A message", [
+      schema.field("content", schema.string_type(), "Message content", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case list.key_find(fields, "content") {
+              Ok(content) -> Ok(content)
+              Error(_) -> Ok(value.String(""))
+            }
+          }
+          _ -> Ok(value.String(""))
+        }
+      }),
+    ])
+
+  let subscription_type =
+    schema.object_type("Subscription", "Root subscription", [
+      schema.field("messageAdded", message_type, "New message", fn(ctx) {
+        // In real usage, this would be called with event data in ctx.data
+        case ctx.data {
+          Some(data) -> Ok(data)
+          None -> Ok(value.Object([#("content", value.String("test"))]))
+        }
+      }),
+    ])
+
+  let test_schema =
+    schema.schema_with_subscriptions(query_type, None, Some(subscription_type))
+
+  // Create context with event data
+  let event_data =
+    value.Object([#("content", value.String("Hello from subscription!"))])
+  let ctx = schema.context(Some(event_data))
+
+  let query = "subscription { messageAdded { content } }"
+
+  case executor.execute(query, test_schema, ctx) {
+    Ok(response) -> {
+      case response.data {
+        value.Object(fields) -> {
+          case list.key_find(fields, "messageAdded") {
+            Ok(value.Object(message_fields)) -> {
+              case list.key_find(message_fields, "content") {
+                Ok(value.String(content)) ->
+                  should.equal(content, "Hello from subscription!")
+                _ -> should.fail()
+              }
+            }
+            _ -> should.fail()
+          }
+        }
+        _ -> should.fail()
+      }
+    }
+    Error(_) -> should.fail()
+  }
+}
+
+// Test: Execute subscription with field selection
+pub fn execute_subscription_with_field_selection_test() {
+  let query_type =
+    schema.object_type("Query", "Root query", [
+      schema.field("dummy", schema.string_type(), "Dummy", fn(_) {
+        Ok(value.String("dummy"))
+      }),
+    ])
+
+  let post_type =
+    schema.object_type("Post", "A post", [
+      schema.field("id", schema.id_type(), "Post ID", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case list.key_find(fields, "id") {
+              Ok(id) -> Ok(id)
+              Error(_) -> Ok(value.String(""))
+            }
+          }
+          _ -> Ok(value.String(""))
+        }
+      }),
+      schema.field("title", schema.string_type(), "Post title", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case list.key_find(fields, "title") {
+              Ok(title) -> Ok(title)
+              Error(_) -> Ok(value.String(""))
+            }
+          }
+          _ -> Ok(value.String(""))
+        }
+      }),
+      schema.field("content", schema.string_type(), "Post content", fn(ctx) {
+        case ctx.data {
+          Some(value.Object(fields)) -> {
+            case list.key_find(fields, "content") {
+              Ok(content) -> Ok(content)
+              Error(_) -> Ok(value.String(""))
+            }
+          }
+          _ -> Ok(value.String(""))
+        }
+      }),
+    ])
+
+  let subscription_type =
+    schema.object_type("Subscription", "Root subscription", [
+      schema.field("postCreated", post_type, "New post", fn(ctx) {
+        case ctx.data {
+          Some(data) -> Ok(data)
+          None ->
+            Ok(
+              value.Object([
+                #("id", value.String("1")),
+                #("title", value.String("Test")),
+                #("content", value.String("Test content")),
+              ]),
+            )
+        }
+      }),
+    ])
+
+  let test_schema =
+    schema.schema_with_subscriptions(query_type, None, Some(subscription_type))
+
+  // Create context with event data
+  let event_data =
+    value.Object([
+      #("id", value.String("123")),
+      #("title", value.String("New Post")),
+      #("content", value.String("This is a new post")),
+    ])
+  let ctx = schema.context(Some(event_data))
+
+  // Query only for id and title, not content
+  let query = "subscription { postCreated { id title } }"
+
+  case executor.execute(query, test_schema, ctx) {
+    Ok(response) -> {
+      case response.data {
+        value.Object(fields) -> {
+          case list.key_find(fields, "postCreated") {
+            Ok(value.Object(post_fields)) -> {
+              // Should have id and title
+              case list.key_find(post_fields, "id") {
+                Ok(value.String(id)) -> should.equal(id, "123")
+                _ -> should.fail()
+              }
+              case list.key_find(post_fields, "title") {
+                Ok(value.String(title)) -> should.equal(title, "New Post")
+                _ -> should.fail()
+              }
+              // Should NOT have content (field selection working)
+              case list.key_find(post_fields, "content") {
+                Error(_) -> should.be_true(True)
+                Ok(_) -> should.fail()
+              }
+            }
+            _ -> should.fail()
+          }
+        }
+        _ -> should.fail()
+      }
+    }
+    Error(_) -> should.fail()
+  }
+}
+
+// Test: Subscription without schema type
+pub fn subscription_without_schema_type_test() {
+  let query_type =
+    schema.object_type("Query", "Root query", [
+      schema.field("dummy", schema.string_type(), "Dummy", fn(_) {
+        Ok(value.String("dummy"))
+      }),
+    ])
+
+  // Schema WITHOUT subscription type
+  let test_schema = schema.schema(query_type, None)
+
+  let ctx = schema.context(None)
+  let query = "subscription { messageAdded }"
+
+  case executor.execute(query, test_schema, ctx) {
+    Error(msg) ->
+      should.equal(msg, "Schema does not define a subscription type")
+    Ok(_) -> should.fail()
+  }
+}

test/swell_test.gleam

···
+import gleeunit
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}

test/value_test.gleam

···
+/// Tests for GraphQL Value types
+///
+/// GraphQL spec Section 2 - Language
+/// Values can be: Null, Int, Float, String, Boolean, Enum, List, Object
+import gleeunit/should
+import swell/value.{Boolean, Enum, Float, Int, List, Null, Object, String}
+
+pub fn null_value_test() {
+  let val = Null
+  should.equal(val, Null)
+}
+
+pub fn int_value_test() {
+  let val = Int(42)
+  should.equal(val, Int(42))
+}
+
+pub fn float_value_test() {
+  let val = Float(3.14)
+  should.equal(val, Float(3.14))
+}
+
+pub fn string_value_test() {
+  let val = String("hello")
+  should.equal(val, String("hello"))
+}
+
+pub fn boolean_true_value_test() {
+  let val = Boolean(True)
+  should.equal(val, Boolean(True))
+}
+
+pub fn boolean_false_value_test() {
+  let val = Boolean(False)
+  should.equal(val, Boolean(False))
+}
+
+pub fn enum_value_test() {
+  let val = Enum("ACTIVE")
+  should.equal(val, Enum("ACTIVE"))
+}
+
+pub fn empty_list_value_test() {
+  let val = List([])
+  should.equal(val, List([]))
+}
+
+pub fn list_of_ints_test() {
+  let val = List([Int(1), Int(2), Int(3)])
+  should.equal(val, List([Int(1), Int(2), Int(3)]))
+}
+
+pub fn nested_list_test() {
+  let val = List([List([Int(1), Int(2)]), List([Int(3), Int(4)])])
+  should.equal(val, List([List([Int(1), Int(2)]), List([Int(3), Int(4)])]))
+}
+
+pub fn empty_object_test() {
+  let val = Object([])
+  should.equal(val, Object([]))
+}
+
+pub fn simple_object_test() {
+  let val = Object([#("name", String("Alice")), #("age", Int(30))])
+  should.equal(val, Object([#("name", String("Alice")), #("age", Int(30))]))
+}
+
+pub fn nested_object_test() {
+  let val =
+    Object([
+      #("user", Object([#("name", String("Bob")), #("active", Boolean(True))])),
+      #("count", Int(5)),
+    ])
+
+  should.equal(
+    val,
+    Object([
+      #("user", Object([#("name", String("Bob")), #("active", Boolean(True))])),
+      #("count", Int(5)),
+    ]),
+  )
+}
+
+pub fn mixed_types_list_test() {
+  let val = List([String("hello"), Int(42), Boolean(True), Null])
+  should.equal(val, List([String("hello"), Int(42), Boolean(True), Null]))
+}