support multiple fields in a combined response and passed variables

birdie_snapshots/mutation_function_generation.accepted

···
 ---
 version: 1.2.0
 title: Mutation function generation
+file: ./test/codegen_test.gleam
+test_name: generate_mutation_test
 ---
 import gleam/dynamic
 import gleam/http
···
 }
 
 pub type CreateUserResponse {
-  CreateUserResponse(createUser: Option(User))
+  CreateUserResponse(create_user: Option(User))
 }
 
 pub fn create_user_response_decoder() -> dynamic.Decoder(CreateUserResponse) {
   fn(data: dynamic.Dynamic) -> Result(CreateUserResponse, List(dynamic.DecodeError)) {
-    use createUser <- result.try(dynamic.field(
+    use create_user <- result.try(dynamic.field(
       "createUser",
       dynamic.optional(user_decoder()),
     )(data))
-    Ok(CreateUserResponse(createUser: createUser))
+    Ok(CreateUserResponse(create_user: create_user))
   }
 }
 
···
   CreateUserResponse,
   String,
 ) {
-  let query = "mutation CreateUser($name: String!) { createUser { id name } }"
+  let query =
+  "mutation CreateUser($name: String!) { createUser(name: $name) { id name } }"
   let variables = json.object([#("name", json.string(name))])
   let body =
   json.object([#("query", json.string(query)), #("variables", variables)])

birdie_snapshots/query_with_inline_array_arguments.accepted

···
+---
+version: 1.2.0
+title: Query with inline array arguments
+file: ./test/codegen_test.gleam
+test_name: generate_inline_array_arguments_test
+---
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type Episode {
+  Episode(id: String, name: String)
+}
+
+pub fn episode_decoder() -> dynamic.Decoder(Episode) {
+  fn(data: dynamic.Dynamic) -> Result(Episode, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.string)(data))
+    use name <- result.try(dynamic.field("name", dynamic.string)(data))
+    Ok(Episode(id: id, name: name))
+  }
+}
+
+pub type GetEpisodesResponse {
+  GetEpisodesResponse(episodes_by_ids: Option(List(Episode)))
+}
+
+pub fn get_episodes_response_decoder() -> dynamic.Decoder(GetEpisodesResponse) {
+  fn(data: dynamic.Dynamic) -> Result(GetEpisodesResponse, List(dynamic.DecodeError)) {
+    use episodes_by_ids <- result.try(dynamic.field(
+      "episodesByIds",
+      dynamic.optional(dynamic.list(episode_decoder())),
+    )(data))
+    Ok(GetEpisodesResponse(episodes_by_ids: episodes_by_ids))
+  }
+}
+
+pub fn get_episodes(endpoint: String) -> Result(GetEpisodesResponse, String) {
+  let query = "query GetEpisodes { episodesByIds(ids: [1, 2, 3]) { id name } }"
+  let variables = json.object([])
+  let body =
+  json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  get_episodes_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

birdie_snapshots/query_with_inline_object_arguments.accepted

···
+---
+version: 1.2.0
+title: Query with inline object arguments
+---
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type CharactersResult {
+  CharactersResult(results: Option(List(Character)))
+}
+
+pub fn characters_result_decoder() -> dynamic.Decoder(CharactersResult) {
+  fn(data: dynamic.Dynamic) -> Result(CharactersResult, List(dynamic.DecodeError)) {
+    use results <- result.try(dynamic.field(
+      "results",
+      dynamic.optional(dynamic.list(character_decoder())),
+    )(data))
+    Ok(CharactersResult(results: results))
+  }
+}
+
+pub type Character {
+  Character(id: String, name: String)
+}
+
+pub fn character_decoder() -> dynamic.Decoder(Character) {
+  fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.string)(data))
+    use name <- result.try(dynamic.field("name", dynamic.string)(data))
+    Ok(Character(id: id, name: name))
+  }
+}
+
+pub type GetCharactersResponse {
+  GetCharactersResponse(characters: Option(CharactersResult))
+}
+
+pub fn get_characters_response_decoder() -> dynamic.Decoder(GetCharactersResponse) {
+  fn(data: dynamic.Dynamic) -> Result(GetCharactersResponse, List(dynamic.DecodeError)) {
+    use characters <- result.try(dynamic.field(
+      "characters",
+      dynamic.optional(characters_result_decoder()),
+    )(data))
+    Ok(GetCharactersResponse(characters: characters))
+  }
+}
+
+pub fn get_characters(endpoint: String) -> Result(GetCharactersResponse, String) {
+  let query =
+  "query GetCharacters { characters(filter: { name: \"rick\", status: \"alive\" }) { results { id name } } }"
+  let variables = json.object([])
+  let body =
+  json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  get_characters_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

birdie_snapshots/query_with_inline_scalar_arguments.accepted

···
+---
+version: 1.2.0
+title: Query with inline scalar arguments
+---
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type Character {
+  Character(id: String, name: String)
+}
+
+pub fn character_decoder() -> dynamic.Decoder(Character) {
+  fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.string)(data))
+    use name <- result.try(dynamic.field("name", dynamic.string)(data))
+    Ok(Character(id: id, name: name))
+  }
+}
+
+pub type GetCharacterResponse {
+  GetCharacterResponse(character: Option(Character))
+}
+
+pub fn get_character_response_decoder() -> dynamic.Decoder(GetCharacterResponse) {
+  fn(data: dynamic.Dynamic) -> Result(GetCharacterResponse, List(dynamic.DecodeError)) {
+    use character <- result.try(dynamic.field(
+      "character",
+      dynamic.optional(character_decoder()),
+    )(data))
+    Ok(GetCharacterResponse(character: character))
+  }
+}
+
+pub fn get_character(endpoint: String) -> Result(GetCharacterResponse, String) {
+  let query = "query GetCharacter { character(id: 1) { id name } }"
+  let variables = json.object([])
+  let body =
+  json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  get_character_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

birdie_snapshots/query_with_multiple_root_fields_and_mixed_arguments.accepted

···
+---
+version: 1.2.0
+title: Query with multiple root fields and mixed arguments
+file: ./test/codegen_test.gleam
+test_name: generate_multiple_root_fields_test
+---
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type CharactersResult {
+  CharactersResult(info: Option(Info), results: Option(List(Character)))
+}
+
+pub fn characters_result_decoder() -> dynamic.Decoder(CharactersResult) {
+  fn(data: dynamic.Dynamic) -> Result(CharactersResult, List(dynamic.DecodeError)) {
+    use info <- result.try(dynamic.field(
+      "info",
+      dynamic.optional(info_decoder()),
+    )(data))
+    use results <- result.try(dynamic.field(
+      "results",
+      dynamic.optional(dynamic.list(character_decoder())),
+    )(data))
+    Ok(CharactersResult(info: info, results: results))
+  }
+}
+
+pub type Info {
+  Info(count: Option(Int))
+}
+
+pub fn info_decoder() -> dynamic.Decoder(Info) {
+  fn(data: dynamic.Dynamic) -> Result(Info, List(dynamic.DecodeError)) {
+    use count <- result.try(dynamic.field(
+      "count",
+      dynamic.optional(dynamic.int),
+    )(data))
+    Ok(Info(count: count))
+  }
+}
+
+pub type Character {
+  Character(name: Option(String))
+}
+
+pub fn character_decoder() -> dynamic.Decoder(Character) {
+  fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
+    use name <- result.try(dynamic.field(
+      "name",
+      dynamic.optional(dynamic.string),
+    )(data))
+    Ok(Character(name: name))
+  }
+}
+
+pub type Location {
+  Location(id: Option(String))
+}
+
+pub fn location_decoder() -> dynamic.Decoder(Location) {
+  fn(data: dynamic.Dynamic) -> Result(Location, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
+    Ok(Location(id: id))
+  }
+}
+
+pub type Episode {
+  Episode(id: Option(String))
+}
+
+pub fn episode_decoder() -> dynamic.Decoder(Episode) {
+  fn(data: dynamic.Dynamic) -> Result(Episode, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
+    Ok(Episode(id: id))
+  }
+}
+
+pub type MultiQueryResponse {
+  MultiQueryResponse(
+    characters: Option(CharactersResult),
+    location: Option(Location),
+    episodes_by_ids: Option(List(Episode)),
+  )
+}
+
+pub fn multi_query_response_decoder() -> dynamic.Decoder(MultiQueryResponse) {
+  fn(data: dynamic.Dynamic) -> Result(MultiQueryResponse, List(dynamic.DecodeError)) {
+    use characters <- result.try(dynamic.field(
+      "characters",
+      dynamic.optional(characters_result_decoder()),
+    )(data))
+    use location <- result.try(dynamic.field(
+      "location",
+      dynamic.optional(location_decoder()),
+    )(data))
+    use episodes_by_ids <- result.try(dynamic.field(
+      "episodesByIds",
+      dynamic.optional(dynamic.list(episode_decoder())),
+    )(data))
+    Ok(
+      MultiQueryResponse(
+        characters: characters,
+        location: location,
+        episodes_by_ids: episodes_by_ids,
+      ),
+    )
+  }
+}
+
+pub fn multi_query(endpoint: String) -> Result(MultiQueryResponse, String) {
+  let query =
+  "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }"
+  let variables = json.object([])
+  let body =
+  json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  multi_query_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

birdie_snapshots/query_with_nested_types_generation.accepted

···
   GetCharacterResponse,
   String,
 ) {
-  let query = "query GetCharacter($id: ID!) { character { id name status } }"
+  let query =
+  "query GetCharacter($id: ID!) { character(id: $id) { id name status } }"
   let variables = json.object([#("id", json.string(id))])
   let body =
   json.object([#("query", json.string(query)), #("variables", variables)])

birdie_snapshots/query_with_variables_function_generation.accepted

···
 }
 
 pub fn get_user(endpoint: String, id: String) -> Result(GetUserResponse, String) {
-  let query = "query GetUser($id: ID!) { user { id name } }"
+  let query = "query GetUser($id: ID!) { user(id: $id) { id name } }"
   let variables = json.object([#("id", json.string(id))])
   let body =
   json.object([#("query", json.string(query)), #("variables", variables)])

example/build/dev/erlang/example/_gleam_artefacts/example.erl

···
 -file("src/example.gleam", 4).
 -spec main() -> nil.
 main() ->
-    Result = graphql@get_characters:get_characters(
+    gleam@io:println(<<"Squall Multi-Field Query Example"/utf8>>),
+    gleam@io:println(<<"=================================\n"/utf8>>),
+    Result = graphql@multi_query:multi_query(
         <<"https://rickandmortyapi.com/graphql"/utf8>>
     ),
     case Result of
         {ok, Response} ->
-            gleam@io:println(<<"Successfully fetched characters!"/utf8>>),
+            gleam@io:println(<<"Response:"/utf8>>),
             gleam@io:debug(Response),
             nil;
 
         {error, Err} ->
-            gleam@io:println(<<"Error: "/utf8, Err/binary>>)
+            gleam@io:println(<<"Error: "/utf8, Err/binary>>),
+            nil
     end.

example/build/dev/erlang/example/_gleam_artefacts/example_with_vars.erl

···
+-module(example_with_vars).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/example_with_vars.gleam").
+-export([main/0]).
+
+-file("src/example_with_vars.gleam", 4).
+-spec main() -> nil.
+main() ->
+    gleam@io:println(
+        <<"Squall Multi-Field Query Example (with Variables)"/utf8>>
+    ),
+    gleam@io:println(
+        <<"==================================================\n"/utf8>>
+    ),
+    gleam@io:println(<<"Calling multi_query_with_vars with:"/utf8>>),
+    gleam@io:println(<<"  page: 2"/utf8>>),
+    gleam@io:println(<<"  name: \"rick\""/utf8>>),
+    gleam@io:println(<<"  locationId: \"1\""/utf8>>),
+    gleam@io:println(<<"  episodeIds: [1, 2]\n"/utf8>>),
+    Result = graphql@multi_query_with_vars:multi_query_with_vars(
+        <<"https://rickandmortyapi.com/graphql"/utf8>>,
+        2,
+        <<"rick"/utf8>>,
+        <<"1"/utf8>>,
+        [1, 2]
+    ),
+    case Result of
+        {ok, Response} ->
+            gleam@io:println(<<"Response:"/utf8>>),
+            gleam@io:debug(Response),
+            nil;
+
+        {error, Err} ->
+            gleam@io:println(<<"Error: "/utf8, Err/binary>>),
+            nil
+    end.

example/build/dev/erlang/example/_gleam_artefacts/graphql@get_character.erl

···
         )
     end.
 
--file("src/graphql/get_character.gleam", 73).
+-file("src/graphql/get_character.gleam", 70).
 -spec get_character(binary(), binary()) -> {ok, get_character_response()} |
     {error, binary()}.
 get_character(Endpoint, Id) ->
-    Query = <<"query GetCharacter($id: ID!) { character { id name status species type gender } }"/utf8>>,
+    Query = <<"query GetCharacter($id: ID!) { character(id: $id) { id name status species type gender } }"/utf8>>,
     Variables = gleam@json:object([{<<"id"/utf8>>, gleam@json:string(Id)}]),
     Body = gleam@json:object(
         [{<<"query"/utf8>>, gleam@json:string(Query)},

example/build/dev/erlang/example/_gleam_artefacts/graphql@get_characters.erl

···
         )
     end.
 
--file("src/graphql/get_characters.gleam", 57).
+-file("src/graphql/get_characters.gleam", 55).
 -spec get_characters_response_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
         get_characters_response()} |
     {error, list(gleam@dynamic:decode_error())}).
···
         )
     end.
 
--file("src/graphql/get_characters.gleam", 72).
+-file("src/graphql/get_characters.gleam", 65).
 -spec get_characters(binary()) -> {ok, get_characters_response()} |
     {error, binary()}.
 get_characters(Endpoint) ->

example/build/dev/erlang/example/_gleam_artefacts/graphql@multi_query.erl

···
+-module(graphql@multi_query).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/graphql/multi_query.gleam").
+-export([info_decoder/0, character_decoder/0, characters_decoder/0, location_decoder/0, episode_decoder/0, multi_query_response_decoder/0, multi_query/1]).
+-export_type([characters/0, info/0, character/0, location/0, episode/0, multi_query_response/0]).
+
+-type characters() :: {characters,
+        gleam@option:option(info()),
+        gleam@option:option(list(character()))}.
+
+-type info() :: {info, gleam@option:option(integer())}.
+
+-type character() :: {character, gleam@option:option(binary())}.
+
+-type location() :: {location, gleam@option:option(binary())}.
+
+-type episode() :: {episode, gleam@option:option(binary())}.
+
+-type multi_query_response() :: {multi_query_response,
+        gleam@option:option(characters()),
+        gleam@option:option(location()),
+        gleam@option:option(list(episode()))}.
+
+-file("src/graphql/multi_query.gleam", 31).
+-spec info_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, info()} |
+    {error, list(gleam@dynamic:decode_error())}).
+info_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"count"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:int/1)
+            ))(Data),
+            fun(Count) -> {ok, {info, Count}} end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 45).
+-spec character_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, character()} |
+    {error, list(gleam@dynamic:decode_error())}).
+character_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"name"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Name) -> {ok, {character, Name}} end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 13).
+-spec characters_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
+        characters()} |
+    {error, list(gleam@dynamic:decode_error())}).
+characters_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"info"/utf8>>,
+                gleam@dynamic:optional(info_decoder())
+            ))(Data),
+            fun(Info) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"results"/utf8>>,
+                        gleam@dynamic:optional(
+                            gleam@dynamic:list(character_decoder())
+                        )
+                    ))(Data),
+                    fun(Results) -> {ok, {characters, Info, Results}} end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 59).
+-spec location_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, location()} |
+    {error, list(gleam@dynamic:decode_error())}).
+location_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"id"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Id) -> {ok, {location, Id}} end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 70).
+-spec episode_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, episode()} |
+    {error, list(gleam@dynamic:decode_error())}).
+episode_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"id"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Id) -> {ok, {episode, Id}} end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 85).
+-spec multi_query_response_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
+        multi_query_response()} |
+    {error, list(gleam@dynamic:decode_error())}).
+multi_query_response_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"characters"/utf8>>,
+                gleam@dynamic:optional(characters_decoder())
+            ))(Data),
+            fun(Characters) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"location"/utf8>>,
+                        gleam@dynamic:optional(location_decoder())
+                    ))(Data),
+                    fun(Location) ->
+                        gleam@result:'try'(
+                            (gleam@dynamic:field(
+                                <<"episodesByIds"/utf8>>,
+                                gleam@dynamic:optional(
+                                    gleam@dynamic:list(episode_decoder())
+                                )
+                            ))(Data),
+                            fun(Episodes_by_ids) ->
+                                {ok,
+                                    {multi_query_response,
+                                        Characters,
+                                        Location,
+                                        Episodes_by_ids}}
+                            end
+                        )
+                    end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query.gleam", 109).
+-spec multi_query(binary()) -> {ok, multi_query_response()} | {error, binary()}.
+multi_query(Endpoint) ->
+    Query = <<"query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }"/utf8>>,
+    Variables = gleam@json:object([]),
+    Body = gleam@json:object(
+        [{<<"query"/utf8>>, gleam@json:string(Query)},
+            {<<"variables"/utf8>>, Variables}]
+    ),
+    gleam@result:'try'(
+        begin
+            _pipe = gleam@http@request:to(Endpoint),
+            gleam@result:map_error(
+                _pipe,
+                fun(_) -> <<"Invalid endpoint URL"/utf8>> end
+            )
+        end,
+        fun(Req) ->
+            Req@1 = begin
+                _pipe@1 = Req,
+                _pipe@2 = gleam@http@request:set_method(_pipe@1, post),
+                _pipe@3 = gleam@http@request:set_body(
+                    _pipe@2,
+                    gleam@json:to_string(Body)
+                ),
+                gleam@http@request:set_header(
+                    _pipe@3,
+                    <<"content-type"/utf8>>,
+                    <<"application/json"/utf8>>
+                )
+            end,
+            gleam@result:'try'(
+                begin
+                    _pipe@4 = gleam@httpc:send(Req@1),
+                    gleam@result:map_error(
+                        _pipe@4,
+                        fun(_) -> <<"HTTP request failed"/utf8>> end
+                    )
+                end,
+                fun(Resp) ->
+                    gleam@result:'try'(
+                        begin
+                            _pipe@5 = gleam@json:decode(
+                                erlang:element(4, Resp),
+                                fun gleam@dynamic:dynamic/1
+                            ),
+                            gleam@result:map_error(
+                                _pipe@5,
+                                fun(_) ->
+                                    <<"Failed to decode JSON response"/utf8>>
+                                end
+                            )
+                        end,
+                        fun(Json_value) ->
+                            gleam@result:'try'(
+                                begin
+                                    _pipe@6 = (gleam@dynamic:field(
+                                        <<"data"/utf8>>,
+                                        fun gleam@dynamic:dynamic/1
+                                    ))(Json_value),
+                                    gleam@result:map_error(
+                                        _pipe@6,
+                                        fun(_) ->
+                                            <<"No data field in response"/utf8>>
+                                        end
+                                    )
+                                end,
+                                fun(Data_field) ->
+                                    _pipe@7 = (multi_query_response_decoder())(
+                                        Data_field
+                                    ),
+                                    gleam@result:map_error(
+                                        _pipe@7,
+                                        fun(_) ->
+                                            <<"Failed to decode response data"/utf8>>
+                                        end
+                                    )
+                                end
+                            )
+                        end
+                    )
+                end
+            )
+        end
+    ).

example/build/dev/erlang/example/_gleam_artefacts/graphql@multi_query_with_vars.erl

···
+-module(graphql@multi_query_with_vars).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/graphql/multi_query_with_vars.gleam").
+-export([info_decoder/0, character_decoder/0, characters_decoder/0, location_decoder/0, episode_decoder/0, multi_query_with_vars_response_decoder/0, multi_query_with_vars/5]).
+-export_type([characters/0, info/0, character/0, location/0, episode/0, multi_query_with_vars_response/0]).
+
+-type characters() :: {characters,
+        gleam@option:option(info()),
+        gleam@option:option(list(character()))}.
+
+-type info() :: {info, gleam@option:option(integer())}.
+
+-type character() :: {character, gleam@option:option(binary())}.
+
+-type location() :: {location,
+        gleam@option:option(binary()),
+        gleam@option:option(binary())}.
+
+-type episode() :: {episode,
+        gleam@option:option(binary()),
+        gleam@option:option(binary())}.
+
+-type multi_query_with_vars_response() :: {multi_query_with_vars_response,
+        gleam@option:option(characters()),
+        gleam@option:option(location()),
+        gleam@option:option(list(episode()))}.
+
+-file("src/graphql/multi_query_with_vars.gleam", 31).
+-spec info_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, info()} |
+    {error, list(gleam@dynamic:decode_error())}).
+info_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"count"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:int/1)
+            ))(Data),
+            fun(Count) -> {ok, {info, Count}} end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 45).
+-spec character_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, character()} |
+    {error, list(gleam@dynamic:decode_error())}).
+character_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"name"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Name) -> {ok, {character, Name}} end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 13).
+-spec characters_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
+        characters()} |
+    {error, list(gleam@dynamic:decode_error())}).
+characters_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"info"/utf8>>,
+                gleam@dynamic:optional(info_decoder())
+            ))(Data),
+            fun(Info) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"results"/utf8>>,
+                        gleam@dynamic:optional(
+                            gleam@dynamic:list(character_decoder())
+                        )
+                    ))(Data),
+                    fun(Results) -> {ok, {characters, Info, Results}} end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 59).
+-spec location_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, location()} |
+    {error, list(gleam@dynamic:decode_error())}).
+location_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"id"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Id) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"name"/utf8>>,
+                        gleam@dynamic:optional(fun gleam@dynamic:string/1)
+                    ))(Data),
+                    fun(Name) -> {ok, {location, Id, Name}} end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 76).
+-spec episode_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, episode()} |
+    {error, list(gleam@dynamic:decode_error())}).
+episode_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"id"/utf8>>,
+                gleam@dynamic:optional(fun gleam@dynamic:string/1)
+            ))(Data),
+            fun(Id) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"name"/utf8>>,
+                        gleam@dynamic:optional(fun gleam@dynamic:string/1)
+                    ))(Data),
+                    fun(Name) -> {ok, {episode, Id, Name}} end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 97).
+-spec multi_query_with_vars_response_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
+        multi_query_with_vars_response()} |
+    {error, list(gleam@dynamic:decode_error())}).
+multi_query_with_vars_response_decoder() ->
+    fun(Data) ->
+        gleam@result:'try'(
+            (gleam@dynamic:field(
+                <<"characters"/utf8>>,
+                gleam@dynamic:optional(characters_decoder())
+            ))(Data),
+            fun(Characters) ->
+                gleam@result:'try'(
+                    (gleam@dynamic:field(
+                        <<"location"/utf8>>,
+                        gleam@dynamic:optional(location_decoder())
+                    ))(Data),
+                    fun(Location) ->
+                        gleam@result:'try'(
+                            (gleam@dynamic:field(
+                                <<"episodesByIds"/utf8>>,
+                                gleam@dynamic:optional(
+                                    gleam@dynamic:list(episode_decoder())
+                                )
+                            ))(Data),
+                            fun(Episodes_by_ids) ->
+                                {ok,
+                                    {multi_query_with_vars_response,
+                                        Characters,
+                                        Location,
+                                        Episodes_by_ids}}
+                            end
+                        )
+                    end
+                )
+            end
+        )
+    end.
+
+-file("src/graphql/multi_query_with_vars.gleam", 124).
+-spec multi_query_with_vars(
+    binary(),
+    integer(),
+    binary(),
+    binary(),
+    list(integer())
+) -> {ok, multi_query_with_vars_response()} | {error, binary()}.
+multi_query_with_vars(Endpoint, Page, Name, Location_id, Episode_ids) ->
+    Query = <<"query MultiQueryWithVars($page: Int, $name: String, $locationId: ID!, $episodeIds: [Int!]!) { characters(page: $page, filter: { name: $name }) { info { count } results { name } } location(id: $locationId) { id name } episodesByIds(ids: $episodeIds) { id name } }"/utf8>>,
+    Variables = gleam@json:object(
+        [{<<"page"/utf8>>, gleam@json:int(Page)},
+            {<<"name"/utf8>>, gleam@json:string(Name)},
+            {<<"locationId"/utf8>>, gleam@json:string(Location_id)},
+            {<<"episodeIds"/utf8>>,
+                gleam@json:array(Episode_ids, fun gleam@json:int/1)}]
+    ),
+    Body = gleam@json:object(
+        [{<<"query"/utf8>>, gleam@json:string(Query)},
+            {<<"variables"/utf8>>, Variables}]
+    ),
+    gleam@result:'try'(
+        begin
+            _pipe = gleam@http@request:to(Endpoint),
+            gleam@result:map_error(
+                _pipe,
+                fun(_) -> <<"Invalid endpoint URL"/utf8>> end
+            )
+        end,
+        fun(Req) ->
+            Req@1 = begin
+                _pipe@1 = Req,
+                _pipe@2 = gleam@http@request:set_method(_pipe@1, post),
+                _pipe@3 = gleam@http@request:set_body(
+                    _pipe@2,
+                    gleam@json:to_string(Body)
+                ),
+                gleam@http@request:set_header(
+                    _pipe@3,
+                    <<"content-type"/utf8>>,
+                    <<"application/json"/utf8>>
+                )
+            end,
+            gleam@result:'try'(
+                begin
+                    _pipe@4 = gleam@httpc:send(Req@1),
+                    gleam@result:map_error(
+                        _pipe@4,
+                        fun(_) -> <<"HTTP request failed"/utf8>> end
+                    )
+                end,
+                fun(Resp) ->
+                    gleam@result:'try'(
+                        begin
+                            _pipe@5 = gleam@json:decode(
+                                erlang:element(4, Resp),
+                                fun gleam@dynamic:dynamic/1
+                            ),
+                            gleam@result:map_error(
+                                _pipe@5,
+                                fun(_) ->
+                                    <<"Failed to decode JSON response"/utf8>>
+                                end
+                            )
+                        end,
+                        fun(Json_value) ->
+                            gleam@result:'try'(
+                                begin
+                                    _pipe@6 = (gleam@dynamic:field(
+                                        <<"data"/utf8>>,
+                                        fun gleam@dynamic:dynamic/1
+                                    ))(Json_value),
+                                    gleam@result:map_error(
+                                        _pipe@6,
+                                        fun(_) ->
+                                            <<"No data field in response"/utf8>>
+                                        end
+                                    )
+                                end,
+                                fun(Data_field) ->
+                                    _pipe@7 = (multi_query_with_vars_response_decoder(
+                                        
+                                    ))(Data_field),
+                                    gleam@result:map_error(
+                                        _pipe@7,
+                                        fun(_) ->
+                                            <<"Failed to decode response data"/utf8>>
+                                        end
+                                    )
+                                end
+                            )
+                        end
+                    )
+                end
+            )
+        end
+    ).

example/build/dev/erlang/example/ebin/example.app

···
                     gleam_stdlib,
                     squall]},
     {description, "Example project using Squall with Rick and Morty API"},
-    {modules, [example,
-               graphql@get_character,
-               graphql@get_characters]},
+    {modules, [example_with_vars,
+               graphql@multi_query_with_vars]},
     {registered, []}
 ]}.

example/build/dev/erlang/example/include/graphql@multi_query_Character.hrl

···
+-record(character, {name :: gleam@option:option(binary())}).

example/build/dev/erlang/example/include/graphql@multi_query_Characters.hrl

···
+-record(characters, {
+    info :: gleam@option:option(graphql@multi_query:info()),
+    results :: gleam@option:option(list(graphql@multi_query:character()))
+}).

example/build/dev/erlang/example/include/graphql@multi_query_Episode.hrl

···
+-record(episode, {id :: gleam@option:option(binary())}).

example/build/dev/erlang/example/include/graphql@multi_query_Info.hrl

···
+-record(info, {count :: gleam@option:option(integer())}).

example/build/dev/erlang/example/include/graphql@multi_query_Location.hrl

···
+-record(location, {id :: gleam@option:option(binary())}).

example/build/dev/erlang/example/include/graphql@multi_query_MultiQueryResponse.hrl

···
+-record(multi_query_response, {
+    characters :: gleam@option:option(graphql@multi_query:characters()),
+    location :: gleam@option:option(graphql@multi_query:location()),
+    episodes_by_ids :: gleam@option:option(list(graphql@multi_query:episode()))
+}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_Character.hrl

···
+-record(character, {name :: gleam@option:option(binary())}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_Characters.hrl

···
+-record(characters, {
+    info :: gleam@option:option(graphql@multi_query_with_vars:info()),
+    results :: gleam@option:option(list(graphql@multi_query_with_vars:character()))
+}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_Episode.hrl

···
+-record(episode, {
+    id :: gleam@option:option(binary()),
+    name :: gleam@option:option(binary())
+}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_Info.hrl

···
+-record(info, {count :: gleam@option:option(integer())}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_Location.hrl

···
+-record(location, {
+    id :: gleam@option:option(binary()),
+    name :: gleam@option:option(binary())
+}).

example/build/dev/erlang/example/include/graphql@multi_query_with_vars_MultiQueryWithVarsResponse.hrl

···
+-record(multi_query_with_vars_response, {
+    characters :: gleam@option:option(graphql@multi_query_with_vars:characters()),
+    location :: gleam@option:option(graphql@multi_query_with_vars:location()),
+    episodes_by_ids :: gleam@option:option(list(graphql@multi_query_with_vars:episode()))
+}).

example/build/dev/erlang/squall/_gleam_artefacts/squall@[e-mail]

···
         list({binary(), squall@internal@schema:type_ref()}),
         gleam@dict:dict(binary(), squall@internal@schema:type())}.
 
--file("src/squall/internal/codegen.gleam", 83).
+-file("src/squall/internal/codegen.gleam", 85).
 ?DOC(false).
 -spec let_var(binary(), glam@doc:document()) -> glam@doc:document().
 let_var(Name, Body) ->
···
     _pipe@1 = glam@doc:concat(_pipe),
     glam@doc:group(_pipe@1).
 
--file("src/squall/internal/codegen.gleam", 90).
+-file("src/squall/internal/codegen.gleam", 92).
 ?DOC(false).
 -spec string_doc(binary()) -> glam@doc:document().
 string_doc(Content) ->
···
         glam@doc:from_string(<<"\""/utf8>>)],
     glam@doc:concat(_pipe@4).
 
--file("src/squall/internal/codegen.gleam", 111).
+-file("src/squall/internal/codegen.gleam", 114).
 ?DOC(false).
 -spec imports_doc() -> glam@doc:document().
 imports_doc() ->
···
     _pipe@1 = gleam@list:map(_pipe, fun glam@doc:from_string/1),
     glam@doc:join(_pipe@1, {line, 1}).
 
--file("src/squall/internal/codegen.gleam", 221).
+-file("src/squall/internal/codegen.gleam", 224).
 ?DOC(false).
 -spec collect_field_types(
     list(squall@internal@parser:selection()),
···
                     )
             end end).
 
--file("src/squall/internal/codegen.gleam", 313).
+-file("src/squall/internal/codegen.gleam", 316).
 ?DOC(false).
 -spec get_base_type_name(squall@internal@schema:type_ref()) -> binary().
 get_base_type_name(Type_ref) ->
···
             get_base_type_name(Inner@1)
     end.
 
--file("src/squall/internal/codegen.gleam", 249).
+-file("src/squall/internal/codegen.gleam", 252).
 ?DOC(false).
 -spec collect_nested_types(
     list(squall@internal@parser:selection()),
···
             end end),
     gleam@result:map(_pipe@4, fun gleam@list:flatten/1).
 
--file("src/squall/internal/codegen.gleam", 480).
+-file("src/squall/internal/codegen.gleam", 483).
 ?DOC(false).
 -spec generate_field_decoder(squall@internal@type_mapping:gleam_type()) -> binary().
 generate_field_decoder(Gleam_type) ->
···
             <<"dynamic.dynamic"/utf8>>
     end.
 
--file("src/squall/internal/codegen.gleam", 718).
+-file("src/squall/internal/codegen.gleam", 750).
+?DOC(false).
+-spec type_ref_to_string(squall@internal@parser:type_ref()) -> binary().
+type_ref_to_string(Type_ref) ->
+    case Type_ref of
+        {named_type_ref, Name} ->
+            Name;
+
+        {list_type_ref, Inner} ->
+            <<<<"["/utf8, (type_ref_to_string(Inner))/binary>>/binary,
+                "]"/utf8>>;
+
+        {non_null_type_ref, Inner@1} ->
+            <<(type_ref_to_string(Inner@1))/binary, "!"/utf8>>
+    end.
+
+-file("src/squall/internal/codegen.gleam", 760).
+?DOC(false).
+-spec capitalize(binary()) -> binary().
+capitalize(S) ->
+    case gleam@string:pop_grapheme(S) of
+        {ok, {First, Rest}} ->
+            <<(gleam@string:uppercase(First))/binary, Rest/binary>>;
+
+        {error, _} ->
+            S
+    end.
+
+-file("src/squall/internal/codegen.gleam", 767).
+?DOC(false).
+-spec to_pascal_case(binary()) -> binary().
+to_pascal_case(S) ->
+    _pipe = S,
+    _pipe@1 = gleam@string:split(_pipe, <<"_"/utf8>>),
+    _pipe@2 = gleam@list:map(_pipe@1, fun capitalize/1),
+    gleam@string:join(_pipe@2, <<""/utf8>>).
+
+-file("src/squall/internal/codegen.gleam", 774).
+?DOC(false).
+-spec format_value(squall@internal@parser:value()) -> binary().
+format_value(Value) ->
+    case Value of
+        {int_value, I} ->
+            gleam@int:to_string(I);
+
+        {float_value, F} ->
+            gleam@float:to_string(F);
+
+        {string_value, S} ->
+            <<<<"\""/utf8, S/binary>>/binary, "\""/utf8>>;
+
+        {boolean_value, true} ->
+            <<"true"/utf8>>;
+
+        {boolean_value, false} ->
+            <<"false"/utf8>>;
+
+        null_value ->
+            <<"null"/utf8>>;
+
+        {variable_value, Name} ->
+            <<"$"/utf8, Name/binary>>;
+
+        {list_value, Values} ->
+            Formatted_values = begin
+                _pipe = Values,
+                _pipe@1 = gleam@list:map(_pipe, fun format_value/1),
+                gleam@string:join(_pipe@1, <<", "/utf8>>)
+            end,
+            <<<<"["/utf8, Formatted_values/binary>>/binary, "]"/utf8>>;
+
+        {object_value, Fields} ->
+            Formatted_fields = begin
+                _pipe@2 = Fields,
+                _pipe@3 = gleam@list:map(
+                    _pipe@2,
+                    fun(Field) ->
+                        {Name@1, Value@1} = Field,
+                        <<<<Name@1/binary, ": "/utf8>>/binary,
+                            (format_value(Value@1))/binary>>
+                    end
+                ),
+                gleam@string:join(_pipe@3, <<", "/utf8>>)
+            end,
+            <<<<"{ "/utf8, Formatted_fields/binary>>/binary, " }"/utf8>>
+    end.
+
+-file("src/squall/internal/codegen.gleam", 803).
+?DOC(false).
+-spec format_arguments(list(squall@internal@parser:argument())) -> binary().
+format_arguments(Arguments) ->
+    case Arguments of
+        [] ->
+            <<""/utf8>>;
+
+        Args ->
+            Formatted_args = begin
+                _pipe = Args,
+                _pipe@1 = gleam@list:map(
+                    _pipe,
+                    fun(Arg) ->
+                        {argument, Name, Value} = Arg,
+                        <<<<Name/binary, ": "/utf8>>/binary,
+                            (format_value(Value))/binary>>
+                    end
+                ),
+                gleam@string:join(_pipe@1, <<", "/utf8>>)
+            end,
+            <<<<"("/utf8, Formatted_args/binary>>/binary, ")"/utf8>>
+    end.
+
+-file("src/squall/internal/codegen.gleam", 731).
 ?DOC(false).
 -spec build_selection_set(list(squall@internal@parser:selection())) -> binary().
 build_selection_set(Selections) ->
     Fields = begin
         _pipe = Selections,
         _pipe@1 = gleam@list:map(_pipe, fun(Selection) -> case Selection of
-                    {field_selection, Name, _, _, Nested} ->
+                    {field_selection, Name, _, Args, Nested} ->
+                        Args_str = format_arguments(Args),
                         case Nested of
                             [] ->
-                                Name;
+                                <<Name/binary, Args_str/binary>>;
 
                             Subs ->
-                                <<<<Name/binary, " "/utf8>>/binary,
+                                <<<<<<Name/binary, Args_str/binary>>/binary,
+                                        " "/utf8>>/binary,
                                     (build_selection_set(Subs))/binary>>
                         end
                 end end),
···
     end,
     <<<<"{ "/utf8, Fields/binary>>/binary, " }"/utf8>>.
 
--file("src/squall/internal/codegen.gleam", 736).
-?DOC(false).
--spec type_ref_to_string(squall@internal@parser:type_ref()) -> binary().
-type_ref_to_string(Type_ref) ->
-    case Type_ref of
-        {named_type_ref, Name} ->
-            Name;
-
-        {list_type_ref, Inner} ->
-            <<<<"["/utf8, (type_ref_to_string(Inner))/binary>>/binary,
-                "]"/utf8>>;
-
-        {non_null_type_ref, Inner@1} ->
-            <<(type_ref_to_string(Inner@1))/binary, "!"/utf8>>
-    end.
-
--file("src/squall/internal/codegen.gleam", 686).
+-file("src/squall/internal/codegen.gleam", 699).
 ?DOC(false).
 -spec build_query_string(squall@internal@parser:operation()) -> binary().
 build_query_string(Operation) ->
···
             " "/utf8>>/binary,
         Selection_set/binary>>.
 
--file("src/squall/internal/codegen.gleam", 746).
-?DOC(false).
--spec capitalize(binary()) -> binary().
-capitalize(S) ->
-    case gleam@string:pop_grapheme(S) of
-        {ok, {First, Rest}} ->
-            <<(gleam@string:uppercase(First))/binary, Rest/binary>>;
-
-        {error, _} ->
-            S
-    end.
-
--file("src/squall/internal/codegen.gleam", 753).
-?DOC(false).
--spec to_pascal_case(binary()) -> binary().
-to_pascal_case(S) ->
-    _pipe = S,
-    _pipe@1 = gleam@string:split(_pipe, <<"_"/utf8>>),
-    _pipe@2 = gleam@list:map(_pipe@1, fun capitalize/1),
-    gleam@string:join(_pipe@2, <<""/utf8>>).
-
--file("src/squall/internal/codegen.gleam", 760).
+-file("src/squall/internal/codegen.gleam", 819).
 ?DOC(false).
 -spec snake_case(binary()) -> binary().
 snake_case(S) ->
···
         end
     ).
 
--file("src/squall/internal/codegen.gleam", 451).
+-file("src/squall/internal/codegen.gleam", 454).
 ?DOC(false).
 -spec generate_field_decoder_with_schema_inner(
     squall@internal@type_mapping:gleam_type(),
···
             generate_field_decoder(Gleam_type)
     end.
 
--file("src/squall/internal/codegen.gleam", 419).
+-file("src/squall/internal/codegen.gleam", 422).
 ?DOC(false).
 -spec generate_field_decoder_with_schema(
     squall@internal@type_mapping:gleam_type(),
···
             end
     end.
 
--file("src/squall/internal/codegen.gleam", 49).
+-file("src/squall/internal/codegen.gleam", 51).
 ?DOC(false).
 -spec comma_list(binary(), list(glam@doc:document()), binary()) -> glam@doc:document().
 comma_list(Open, Content, Close) ->
···
             glam@doc:concat(_pipe@2)
     end.
 
--file("src/squall/internal/codegen.gleam", 42).
+-file("src/squall/internal/codegen.gleam", 44).
 ?DOC(false).
 -spec call_doc(binary(), list(glam@doc:document())) -> glam@doc:document().
 call_doc(Function, Args) ->
···
     _pipe@2 = glam@doc:concat(_pipe@1),
     glam@doc:group(_pipe@2).
 
--file("src/squall/internal/codegen.gleam", 69).
+-file("src/squall/internal/codegen.gleam", 71).
 ?DOC(false).
 -spec block(list(glam@doc:document())) -> glam@doc:document().
 block(Body) ->
···
         glam@doc:from_string(<<"}"/utf8>>)],
     glam@doc:concat(_pipe@3).
 
--file("src/squall/internal/codegen.gleam", 660).
+-file("src/squall/internal/codegen.gleam", 665).
 ?DOC(false).
 -spec encode_variable_value(binary(), squall@internal@type_mapping:gleam_type()) -> glam@doc:document().
 encode_variable_value(Var_name, Gleam_type) ->
···
         bool_type ->
             call_doc(<<"json.bool"/utf8>>, [glam@doc:from_string(Var_name)]);
 
-        {list_type, _} ->
+        {list_type, Inner} ->
+            Encoder = case Inner of
+                string_type ->
+                    <<"json.string"/utf8>>;
+
+                int_type ->
+                    <<"json.int"/utf8>>;
+
+                float_type ->
+                    <<"json.float"/utf8>>;
+
+                bool_type ->
+                    <<"json.bool"/utf8>>;
+
+                _ ->
+                    <<"json.string"/utf8>>
+            end,
             call_doc(
                 <<"json.array"/utf8>>,
                 [glam@doc:from_string(<<"from: "/utf8, Var_name/binary>>),
-                    glam@doc:from_string(<<"of: json.string"/utf8>>)]
+                    glam@doc:from_string(<<"of: "/utf8, Encoder/binary>>)]
             );
 
-        {option_type, Inner} ->
+        {option_type, Inner@1} ->
             call_doc(
                 <<"json.nullable"/utf8>>,
                 [glam@doc:from_string(Var_name),
-                    encode_variable_value(<<"value"/utf8>>, Inner)]
+                    encode_variable_value(<<"value"/utf8>>, Inner@1)]
             );
 
         {custom_type, _} ->
             call_doc(<<"json.string"/utf8>>, [glam@doc:from_string(Var_name)])
     end.
 
--file("src/squall/internal/codegen.gleam", 495).
+-file("src/squall/internal/codegen.gleam", 498).
 ?DOC(false).
 -spec generate_function(
     binary(),
···
                                 )
                             end,
                             fun(Gleam_type) ->
+                                Param_name = snake_case(erlang:element(2, Var)),
                                 {ok,
                                     glam@doc:from_string(
-                                        <<<<(erlang:element(2, Var))/binary,
-                                                ": "/utf8>>/binary,
+                                        <<<<Param_name/binary, ": "/utf8>>/binary,
                                             (squall@internal@type_mapping:to_gleam_type_string(
                                                 Gleam_type
                                             ))/binary>>
···
                                 )
                             end,
                             fun(Gleam_type@1) ->
+                                Param_name@1 = snake_case(
+                                    erlang:element(2, Var@1)
+                                ),
                                 Value_encoder = encode_variable_value(
-                                    erlang:element(2, Var@1),
+                                    Param_name@1,
                                     Gleam_type@1
                                 ),
                                 {ok,
···
             block(Body_docs)]
     ).
 
--file("src/squall/internal/codegen.gleam", 103).
+-file("src/squall/internal/codegen.gleam", 105).
 ?DOC(false).
 -spec sanitize_field_name(binary()) -> binary().
 sanitize_field_name(Name) ->
+    Snake_cased = snake_case(Name),
     case gleam@list:contains(
         [<<"as"/utf8>>,
             <<"assert"/utf8>>,
···
             <<"try"/utf8>>,
             <<"type"/utf8>>,
             <<"use"/utf8>>],
-        Name
+        Snake_cased
     ) of
         true ->
-            <<Name/binary, "_"/utf8>>;
+            <<Snake_cased/binary, "_"/utf8>>;
 
         false ->
-            Name
+            Snake_cased
     end.
 
--file("src/squall/internal/codegen.gleam", 322).
+-file("src/squall/internal/codegen.gleam", 325).
 ?DOC(false).
 -spec generate_type_definition(
     binary(),
···
     _pipe@5 = glam@doc:concat(_pipe@4),
     glam@doc:group(_pipe@5).
 
--file("src/squall/internal/codegen.gleam", 359).
+-file("src/squall/internal/codegen.gleam", 362).
 ?DOC(false).
 -spec generate_decoder_with_schema(
     binary(),
···
             block([Inner_fn])]
     ).
 
--file("src/squall/internal/codegen.gleam", 130).
+-file("src/squall/internal/codegen.gleam", 133).
 ?DOC(false).
 -spec generate_operation(
     binary(),

example/build/dev/erlang/squall/_gleam_artefacts/squall@[e-mail]

···
     _pipe = tokenize_helper(Source, 1, 1, []),
     gleam@result:map(_pipe, fun lists:reverse/1).
 
--file("src/squall/internal/parser.gleam", 709).
+-file("src/squall/internal/parser.gleam", 711).
 ?DOC(false).
 -spec peek_token(parser_state()) -> {ok, token_position()} |
     {error, squall@internal@error:error()}.
···
                     <<"Unexpected end of input"/utf8>>}}
     end.
 
--file("src/squall/internal/parser.gleam", 716).
+-file("src/squall/internal/parser.gleam", 718).
 ?DOC(false).
 -spec advance(parser_state()) -> parser_state().
 advance(State) ->
···
             {none, State}
     end.
 
--file("src/squall/internal/parser.gleam", 693).
+-file("src/squall/internal/parser.gleam", 695).
 ?DOC(false).
 -spec parse_name(parser_state()) -> {ok, {binary(), parser_state()}} |
     {error, squall@internal@error:error()}.
···
             end end
     ).
 
--file("src/squall/internal/parser.gleam", 738).
+-file("src/squall/internal/parser.gleam", 740).
 ?DOC(false).
 -spec tokens_equal(token(), token()) -> boolean().
 tokens_equal(A, B) ->
···
             false
     end.
 
--file("src/squall/internal/parser.gleam", 757).
+-file("src/squall/internal/parser.gleam", 759).
 ?DOC(false).
 -spec token_to_string(token()) -> binary().
 token_to_string(Token) ->
···
             <<"end of input"/utf8>>
     end.
 
--file("src/squall/internal/parser.gleam", 720).
+-file("src/squall/internal/parser.gleam", 722).
 ?DOC(false).
 -spec expect_token(parser_state(), token(), binary()) -> {ok, parser_state()} |
     {error, squall@internal@error:error()}.
···
             {ok, {[], State}}
     end.
 
--file("src/squall/internal/parser.gleam", 779).
+-file("src/squall/internal/parser.gleam", 781).
 ?DOC(false).
 -spec skip_insignificant(parser_state()) -> parser_state().
 skip_insignificant(State) ->
···
         fun(Token_pos) -> case erlang:element(2, Token_pos) of
                 right_bracket ->
                     {ok, {{list_value, lists:reverse(Acc)}, advance(State)}};
+
+                comma ->
+                    parse_list_value(advance(State), Acc);
 
                 _ ->
                     gleam@result:'try'(
···
             {ok, {[], State}}
     end.
 
--file("src/squall/internal/parser.gleam", 670).
+-file("src/squall/internal/parser.gleam", 671).
 ?DOC(false).
 -spec parse_object_value(parser_state(), list({binary(), value()})) -> {ok,
         {value(), parser_state()}} |
···
         fun(Token_pos) -> case erlang:element(2, Token_pos) of
                 right_brace ->
                     {ok, {{object_value, lists:reverse(Acc)}, advance(State)}};
+
+                comma ->
+                    parse_object_value(advance(State), Acc);
 
                 {name, _} ->
                     gleam@result:'try'(

example/build/dev/erlang/squall/ebin/squall.app

···
 {application, squall, [
-    {vsn, "1.0.0"},
+    {vsn, "0.1.0"},
     {applications, [argv,
                     filepath,
                     glam,

example/build/packages/packages.toml

···
 [packages]
-gleam_http = "3.7.1"
-thoas = "1.2.1"
-squall = "1.0.0"
-simplifile = "2.3.0"
-filepath = "1.0.0"
+gleam_stdlib = "0.39.0"
+argv = "1.0.2"
 gleam_httpc = "2.3.0"
 glam = "2.0.2"
+squall = "1.0.0"
+thoas = "1.2.1"
+filepath = "1.0.0"
 gleam_json = "1.0.1"
-gleam_stdlib = "0.39.0"
-argv = "1.0.2"
+simplifile = "2.3.0"
+gleam_http = "3.7.1"

example/src/example.gleam

···
 import gleam/io
-import graphql/get_characters
+import graphql/multi_query
 
 pub fn main() {
+  io.println("Squall Multi-Field Query Example")
+  io.println("=================================\n")
+
   let result =
-    get_characters.get_characters("https://rickandmortyapi.com/graphql")
+    multi_query.multi_query("https://rickandmortyapi.com/graphql")
 
   case result {
     Ok(response) -> {
-      // Handle response with list of characters
-      io.println("Successfully fetched characters!")
+      io.println("Response:")
       io.debug(response)
       Nil
     }
     Error(err) -> {
       io.println("Error: " <> err)
+      Nil
     }
   }
 }

example/src/example_with_vars.gleam

···
+import gleam/io
+import graphql/multi_query_with_vars
+
+pub fn main() {
+  io.println("Squall Multi-Field Query Example (with Variables)")
+  io.println("==================================================\n")
+
+  io.println("Calling multi_query_with_vars with:")
+  io.println("  page: 2")
+  io.println("  name: \"rick\"")
+  io.println("  locationId: \"1\"")
+  io.println("  episodeIds: [1, 2]\n")
+
+  let result =
+    multi_query_with_vars.multi_query_with_vars(
+      "https://rickandmortyapi.com/graphql",
+      2,
+      "rick",
+      "1",
+      [1, 2],
+    )
+
+  case result {
+    Ok(response) -> {
+      io.println("Response:")
+      io.debug(response)
+      Nil
+    }
+    Error(err) -> {
+      io.println("Error: " <> err)
+      Nil
+    }
+  }
+}

example/src/graphql/get_character.gleam

···
 
 pub fn character_decoder() -> dynamic.Decoder(Character) {
   fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
-    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(
-      data,
-    ))
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
     use name <- result.try(dynamic.field(
       "name",
       dynamic.optional(dynamic.string),
···
       "gender",
       dynamic.optional(dynamic.string),
     )(data))
-    Ok(Character(
-      id: id,
-      name: name,
-      status: status,
-      species: species,
-      type_: type_,
-      gender: gender,
-    ))
+    Ok(
+      Character(
+        id: id,
+        name: name,
+        status: status,
+        species: species,
+        type_: type_,
+        gender: gender,
+      ),
+    )
   }
 }
 
···
 }
 
 pub fn get_character_response_decoder() -> dynamic.Decoder(GetCharacterResponse) {
-  fn(data: dynamic.Dynamic) -> Result(
-    GetCharacterResponse,
-    List(dynamic.DecodeError),
-  ) {
+  fn(data: dynamic.Dynamic) -> Result(GetCharacterResponse, List(dynamic.DecodeError)) {
     use character <- result.try(dynamic.field(
       "character",
       dynamic.optional(character_decoder()),
···
   }
 }
 
-pub fn get_character(
-  endpoint: String,
-  id: String,
-) -> Result(GetCharacterResponse, String) {
+pub fn get_character(endpoint: String, id: String) -> Result(
+  GetCharacterResponse,
+  String,
+) {
   let query =
-    "query GetCharacter($id: ID!) { character { id name status species type gender } }"
+  "query GetCharacter($id: ID!) { character(id: $id) { id name status species type gender } }"
   let variables = json.object([#("id", json.string(id))])
   let body =
-    json.object([#("query", json.string(query)), #("variables", variables)])
+  json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(
     request.to(endpoint)
     |> result.map_error(fn(_) { "Invalid endpoint URL" }),
   )
-  let req =
-    req
-    |> request.set_method(http.Post)
-    |> request.set_body(json.to_string(body))
-    |> request.set_header("content-type", "application/json")
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
   use resp <- result.try(
     httpc.send(req)
     |> result.map_error(fn(_) { "HTTP request failed" }),

example/src/graphql/get_characters.gleam

···
 
 pub fn character_decoder() -> dynamic.Decoder(Character) {
   fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
-    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(
-      data,
-    ))
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
     use name <- result.try(dynamic.field(
       "name",
       dynamic.optional(dynamic.string),
···
   GetCharactersResponse(characters: Option(Characters))
 }
 
-pub fn get_characters_response_decoder() -> dynamic.Decoder(
-  GetCharactersResponse,
-) {
-  fn(data: dynamic.Dynamic) -> Result(
-    GetCharactersResponse,
-    List(dynamic.DecodeError),
-  ) {
+pub fn get_characters_response_decoder() -> dynamic.Decoder(GetCharactersResponse) {
+  fn(data: dynamic.Dynamic) -> Result(GetCharactersResponse, List(dynamic.DecodeError)) {
     use characters <- result.try(dynamic.field(
       "characters",
       dynamic.optional(characters_decoder()),
···
 
 pub fn get_characters(endpoint: String) -> Result(GetCharactersResponse, String) {
   let query =
-    "query GetCharacters { characters { results { id name status species } } }"
+  "query GetCharacters { characters { results { id name status species } } }"
   let variables = json.object([])
   let body =
-    json.object([#("query", json.string(query)), #("variables", variables)])
+  json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(
     request.to(endpoint)
     |> result.map_error(fn(_) { "Invalid endpoint URL" }),
   )
-  let req =
-    req
-    |> request.set_method(http.Post)
-    |> request.set_body(json.to_string(body))
-    |> request.set_header("content-type", "application/json")
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
   use resp <- result.try(
     httpc.send(req)
     |> result.map_error(fn(_) { "HTTP request failed" }),

example/src/graphql/multi_query.gleam

···
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type Characters {
+  Characters(info: Option(Info), results: Option(List(Character)))
+}
+
+pub fn characters_decoder() -> dynamic.Decoder(Characters) {
+  fn(data: dynamic.Dynamic) -> Result(Characters, List(dynamic.DecodeError)) {
+    use info <- result.try(dynamic.field(
+      "info",
+      dynamic.optional(info_decoder()),
+    )(data))
+    use results <- result.try(dynamic.field(
+      "results",
+      dynamic.optional(dynamic.list(character_decoder())),
+    )(data))
+    Ok(Characters(info: info, results: results))
+  }
+}
+
+pub type Info {
+  Info(count: Option(Int))
+}
+
+pub fn info_decoder() -> dynamic.Decoder(Info) {
+  fn(data: dynamic.Dynamic) -> Result(Info, List(dynamic.DecodeError)) {
+    use count <- result.try(dynamic.field(
+      "count",
+      dynamic.optional(dynamic.int),
+    )(data))
+    Ok(Info(count: count))
+  }
+}
+
+pub type Character {
+  Character(name: Option(String))
+}
+
+pub fn character_decoder() -> dynamic.Decoder(Character) {
+  fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
+    use name <- result.try(dynamic.field(
+      "name",
+      dynamic.optional(dynamic.string),
+    )(data))
+    Ok(Character(name: name))
+  }
+}
+
+pub type Location {
+  Location(id: Option(String))
+}
+
+pub fn location_decoder() -> dynamic.Decoder(Location) {
+  fn(data: dynamic.Dynamic) -> Result(Location, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
+    Ok(Location(id: id))
+  }
+}
+
+pub type Episode {
+  Episode(id: Option(String))
+}
+
+pub fn episode_decoder() -> dynamic.Decoder(Episode) {
+  fn(data: dynamic.Dynamic) -> Result(Episode, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(data))
+    Ok(Episode(id: id))
+  }
+}
+
+pub type MultiQueryResponse {
+  MultiQueryResponse(
+    characters: Option(Characters),
+    location: Option(Location),
+    episodes_by_ids: Option(List(Episode)),
+  )
+}
+
+pub fn multi_query_response_decoder() -> dynamic.Decoder(MultiQueryResponse) {
+  fn(data: dynamic.Dynamic) -> Result(MultiQueryResponse, List(dynamic.DecodeError)) {
+    use characters <- result.try(dynamic.field(
+      "characters",
+      dynamic.optional(characters_decoder()),
+    )(data))
+    use location <- result.try(dynamic.field(
+      "location",
+      dynamic.optional(location_decoder()),
+    )(data))
+    use episodes_by_ids <- result.try(dynamic.field(
+      "episodesByIds",
+      dynamic.optional(dynamic.list(episode_decoder())),
+    )(data))
+    Ok(
+      MultiQueryResponse(
+        characters: characters,
+        location: location,
+        episodes_by_ids: episodes_by_ids,
+      ),
+    )
+  }
+}
+
+pub fn multi_query(endpoint: String) -> Result(MultiQueryResponse, String) {
+  let query =
+  "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }"
+  let variables = json.object([])
+  let body =
+  json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req = req
+  |> request.set_method(http.Post)
+  |> request.set_body(json.to_string(body))
+  |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  multi_query_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

example/src/graphql/multi_query.gql

···
+query MultiQuery {
+  characters(page: 2, filter: { name: "rick" }) {
+    info {
+      count
+    }
+    results {
+      name
+    }
+  }
+  location(id: 1) {
+    id
+  }
+  episodesByIds(ids: [1, 2]) {
+    id
+  }
+}

example/src/graphql/multi_query_with_vars.gleam

···
+import gleam/dynamic
+import gleam/http
+import gleam/http/request
+import gleam/httpc
+import gleam/json
+import gleam/option.{type Option}
+import gleam/result
+
+pub type Characters {
+  Characters(info: Option(Info), results: Option(List(Character)))
+}
+
+pub fn characters_decoder() -> dynamic.Decoder(Characters) {
+  fn(data: dynamic.Dynamic) -> Result(Characters, List(dynamic.DecodeError)) {
+    use info <- result.try(dynamic.field(
+      "info",
+      dynamic.optional(info_decoder()),
+    )(data))
+    use results <- result.try(dynamic.field(
+      "results",
+      dynamic.optional(dynamic.list(character_decoder())),
+    )(data))
+    Ok(Characters(info: info, results: results))
+  }
+}
+
+pub type Info {
+  Info(count: Option(Int))
+}
+
+pub fn info_decoder() -> dynamic.Decoder(Info) {
+  fn(data: dynamic.Dynamic) -> Result(Info, List(dynamic.DecodeError)) {
+    use count <- result.try(dynamic.field(
+      "count",
+      dynamic.optional(dynamic.int),
+    )(data))
+    Ok(Info(count: count))
+  }
+}
+
+pub type Character {
+  Character(name: Option(String))
+}
+
+pub fn character_decoder() -> dynamic.Decoder(Character) {
+  fn(data: dynamic.Dynamic) -> Result(Character, List(dynamic.DecodeError)) {
+    use name <- result.try(dynamic.field(
+      "name",
+      dynamic.optional(dynamic.string),
+    )(data))
+    Ok(Character(name: name))
+  }
+}
+
+pub type Location {
+  Location(id: Option(String), name: Option(String))
+}
+
+pub fn location_decoder() -> dynamic.Decoder(Location) {
+  fn(data: dynamic.Dynamic) -> Result(Location, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(
+      data,
+    ))
+    use name <- result.try(dynamic.field(
+      "name",
+      dynamic.optional(dynamic.string),
+    )(data))
+    Ok(Location(id: id, name: name))
+  }
+}
+
+pub type Episode {
+  Episode(id: Option(String), name: Option(String))
+}
+
+pub fn episode_decoder() -> dynamic.Decoder(Episode) {
+  fn(data: dynamic.Dynamic) -> Result(Episode, List(dynamic.DecodeError)) {
+    use id <- result.try(dynamic.field("id", dynamic.optional(dynamic.string))(
+      data,
+    ))
+    use name <- result.try(dynamic.field(
+      "name",
+      dynamic.optional(dynamic.string),
+    )(data))
+    Ok(Episode(id: id, name: name))
+  }
+}
+
+pub type MultiQueryWithVarsResponse {
+  MultiQueryWithVarsResponse(
+    characters: Option(Characters),
+    location: Option(Location),
+    episodes_by_ids: Option(List(Episode)),
+  )
+}
+
+pub fn multi_query_with_vars_response_decoder() -> dynamic.Decoder(
+  MultiQueryWithVarsResponse,
+) {
+  fn(data: dynamic.Dynamic) -> Result(
+    MultiQueryWithVarsResponse,
+    List(dynamic.DecodeError),
+  ) {
+    use characters <- result.try(dynamic.field(
+      "characters",
+      dynamic.optional(characters_decoder()),
+    )(data))
+    use location <- result.try(dynamic.field(
+      "location",
+      dynamic.optional(location_decoder()),
+    )(data))
+    use episodes_by_ids <- result.try(dynamic.field(
+      "episodesByIds",
+      dynamic.optional(dynamic.list(episode_decoder())),
+    )(data))
+    Ok(MultiQueryWithVarsResponse(
+      characters: characters,
+      location: location,
+      episodes_by_ids: episodes_by_ids,
+    ))
+  }
+}
+
+pub fn multi_query_with_vars(
+  endpoint: String,
+  page: Int,
+  name: String,
+  location_id: String,
+  episode_ids: List(Int),
+) -> Result(MultiQueryWithVarsResponse, String) {
+  let query =
+    "query MultiQueryWithVars($page: Int, $name: String, $locationId: ID!, $episodeIds: [Int!]!) { characters(page: $page, filter: { name: $name }) { info { count } results { name } } location(id: $locationId) { id name } episodesByIds(ids: $episodeIds) { id name } }"
+  let variables =
+    json.object([
+      #("page", json.int(page)),
+      #("name", json.string(name)),
+      #("locationId", json.string(location_id)),
+      #("episodeIds", json.array(from: episode_ids, of: json.int)),
+    ])
+  let body =
+    json.object([#("query", json.string(query)), #("variables", variables)])
+  use req <- result.try(
+    request.to(endpoint)
+    |> result.map_error(fn(_) { "Invalid endpoint URL" }),
+  )
+  let req =
+    req
+    |> request.set_method(http.Post)
+    |> request.set_body(json.to_string(body))
+    |> request.set_header("content-type", "application/json")
+  use resp <- result.try(
+    httpc.send(req)
+    |> result.map_error(fn(_) { "HTTP request failed" }),
+  )
+  use json_value <- result.try(
+    json.decode(from: resp.body, using: dynamic.dynamic)
+    |> result.map_error(fn(_) { "Failed to decode JSON response" }),
+  )
+  use data_field <- result.try(
+    dynamic.field("data", dynamic.dynamic)(json_value)
+    |> result.map_error(fn(_) { "No data field in response" }),
+  )
+  multi_query_with_vars_response_decoder()(data_field)
+  |> result.map_error(fn(_) { "Failed to decode response data" })
+}

example/src/graphql/multi_query_with_vars.gql

···
+query MultiQueryWithVars($page: Int, $name: String, $locationId: ID!, $episodeIds: [Int!]!) {
+  characters(page: $page, filter: { name: $name }) {
+    info {
+      count
+    }
+    results {
+      name
+    }
+  }
+  location(id: $locationId) {
+    id
+    name
+  }
+  episodesByIds(ids: $episodeIds) {
+    id
+    name
+  }
+}

src/squall/internal/codegen.gleam

···
 import glam/doc.{type Document}
 import gleam/dict
+import gleam/float
+import gleam/int
 import gleam/list
 import gleam/option.{None, Some}
 import gleam/result
···
   |> doc.concat
 }
 
-/// Sanitize field names by appending underscore to reserved keywords
+/// Sanitize field names by converting to snake_case and appending underscore to reserved keywords
 fn sanitize_field_name(name: String) -> String {
-  case list.contains(reserved_keywords, name) {
-    True -> name <> "_"
-    False -> name
+  let snake_cased = snake_case(name)
+  case list.contains(reserved_keywords, snake_cased) {
+    True -> snake_cased <> "_"
+    False -> snake_cased
   }
 }
 
···
             type_mapping.parser_type_to_schema_type(var.type_ref)
             |> result.then(type_mapping.graphql_to_gleam),
           )
+          let param_name = snake_case(var.name)
           Ok(
             doc.from_string(
-              var.name <> ": " <> type_mapping.to_gleam_type_string(gleam_type),
+              param_name <> ": " <> type_mapping.to_gleam_type_string(gleam_type),
             ),
           )
         })
···
             type_mapping.parser_type_to_schema_type(var.type_ref)
             |> result.then(type_mapping.graphql_to_gleam),
           )
-          let value_encoder = encode_variable_value(var.name, gleam_type)
+          let param_name = snake_case(var.name)
+          let value_encoder = encode_variable_value(param_name, gleam_type)
           Ok(
             doc.concat([
               doc.from_string("#("),
···
     type_mapping.FloatType ->
       call_doc("json.float", [doc.from_string(var_name)])
     type_mapping.BoolType -> call_doc("json.bool", [doc.from_string(var_name)])
-    type_mapping.ListType(_inner) ->
+    type_mapping.ListType(inner) -> {
+      let encoder = case inner {
+        type_mapping.StringType -> "json.string"
+        type_mapping.IntType -> "json.int"
+        type_mapping.FloatType -> "json.float"
+        type_mapping.BoolType -> "json.bool"
+        _ -> "json.string"
+      }
       call_doc("json.array", [
         doc.from_string("from: " <> var_name),
-        doc.from_string("of: json.string"),
+        doc.from_string("of: " <> encoder),
       ])
+    }
     type_mapping.OptionType(inner) ->
       call_doc("json.nullable", [
         doc.from_string(var_name),
···
     selections
     |> list.map(fn(selection) {
       case selection {
-        parser.FieldSelection(name, _alias, _args, nested) -> {
+        parser.FieldSelection(name, _alias, args, nested) -> {
+          let args_str = format_arguments(args)
           case nested {
-            [] -> name
-            subs -> name <> " " <> build_selection_set(subs)
+            [] -> name <> args_str
+            subs -> name <> args_str <> " " <> build_selection_set(subs)
           }
         }
       }
···
   |> string.split("_")
   |> list.map(capitalize)
   |> string.join("")
+}
+
+fn format_value(value: parser.Value) -> String {
+  case value {
+    parser.IntValue(i) -> int.to_string(i)
+    parser.FloatValue(f) -> float.to_string(f)
+    parser.StringValue(s) -> "\"" <> s <> "\""
+    parser.BooleanValue(True) -> "true"
+    parser.BooleanValue(False) -> "false"
+    parser.NullValue -> "null"
+    parser.VariableValue(name) -> "$" <> name
+    parser.ListValue(values) -> {
+      let formatted_values =
+        values
+        |> list.map(format_value)
+        |> string.join(", ")
+      "[" <> formatted_values <> "]"
+    }
+    parser.ObjectValue(fields) -> {
+      let formatted_fields =
+        fields
+        |> list.map(fn(field) {
+          let #(name, value) = field
+          name <> ": " <> format_value(value)
+        })
+        |> string.join(", ")
+      "{ " <> formatted_fields <> " }"
+    }
+  }
+}
+
+fn format_arguments(arguments: List(parser.Argument)) -> String {
+  case arguments {
+    [] -> ""
+    args -> {
+      let formatted_args =
+        args
+        |> list.map(fn(arg) {
+          let parser.Argument(name, value) = arg
+          name <> ": " <> format_value(value)
+        })
+        |> string.join(", ")
+      "(" <> formatted_args <> ")"
+    }
+  }
 }
 
 fn snake_case(s: String) -> String {

src/squall/internal/parser.gleam

···
 
   case token_pos.token {
     RightBracket -> Ok(#(ListValue(list.reverse(acc)), advance(state)))
+    Comma -> parse_list_value(advance(state), acc)
     _ -> {
       use #(value, state) <- result.try(parse_value(state))
       parse_list_value(state, [value, ..acc])
···
 
   case token_pos.token {
     RightBrace -> Ok(#(ObjectValue(list.reverse(acc)), advance(state)))
+    Comma -> parse_object_value(advance(state), acc)
     Name(_) -> {
       use #(name, state) <- result.try(parse_name(state))
       use state <- result.try(expect_token(state, Colon, "object field value"))

test/codegen_test.gleam

···
     Error(_) -> Nil
   }
 }
+
+// Test: Generate query with inline scalar arguments
+pub fn generate_inline_scalar_arguments_test() {
+  let query_source =
+    "
+    query GetCharacter {
+      character(id: 1) {
+        id
+        name
+      }
+    }
+  "
+
+  let assert Ok(operation) = parser.parse(query_source)
+
+  let character_fields = [
+    schema.Field(
+      "id",
+      schema.NonNullType(schema.NamedType("ID", schema.Scalar)),
+      [],
+      None,
+    ),
+    schema.Field(
+      "name",
+      schema.NonNullType(schema.NamedType("String", schema.Scalar)),
+      [],
+      None,
+    ),
+  ]
+
+  let mock_schema =
+    schema.Schema(
+      Some("Query"),
+      None,
+      None,
+      dict.from_list([
+        #("Character", schema.ObjectType("Character", character_fields, None)),
+        #(
+          "Query",
+          schema.ObjectType(
+            "Query",
+            [
+              schema.Field(
+                "character",
+                schema.NamedType("Character", schema.Object),
+                [
+                  schema.InputValue(
+                    "id",
+                    schema.NonNullType(schema.NamedType("ID", schema.Scalar)),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+            ],
+            None,
+          ),
+        ),
+      ]),
+    )
+
+  let result =
+    codegen.generate_operation("get_character", operation, mock_schema, "")
+
+  case result {
+    Ok(code) -> {
+      code
+      |> birdie.snap(title: "Query with inline scalar arguments")
+    }
+    Error(_) -> Nil
+  }
+}
+
+// Test: Generate query with inline object arguments
+pub fn generate_inline_object_arguments_test() {
+  let query_source =
+    "
+    query GetCharacters {
+      characters(filter: { name: \"rick\", status: \"alive\" }) {
+        results {
+          id
+          name
+        }
+      }
+    }
+  "
+
+  let assert Ok(operation) = parser.parse(query_source)
+
+  let character_fields = [
+    schema.Field(
+      "id",
+      schema.NonNullType(schema.NamedType("ID", schema.Scalar)),
+      [],
+      None,
+    ),
+    schema.Field(
+      "name",
+      schema.NonNullType(schema.NamedType("String", schema.Scalar)),
+      [],
+      None,
+    ),
+  ]
+
+  let characters_result_fields = [
+    schema.Field(
+      "results",
+      schema.ListType(schema.NamedType("Character", schema.Object)),
+      [],
+      None,
+    ),
+  ]
+
+  let mock_schema =
+    schema.Schema(
+      Some("Query"),
+      None,
+      None,
+      dict.from_list([
+        #("Character", schema.ObjectType("Character", character_fields, None)),
+        #(
+          "CharactersResult",
+          schema.ObjectType("CharactersResult", characters_result_fields, None),
+        ),
+        #(
+          "Query",
+          schema.ObjectType(
+            "Query",
+            [
+              schema.Field(
+                "characters",
+                schema.NamedType("CharactersResult", schema.Object),
+                [
+                  schema.InputValue(
+                    "filter",
+                    schema.NamedType("FilterInput", schema.InputObject),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+            ],
+            None,
+          ),
+        ),
+      ]),
+    )
+
+  let result =
+    codegen.generate_operation("get_characters", operation, mock_schema, "")
+
+  case result {
+    Ok(code) -> {
+      code
+      |> birdie.snap(title: "Query with inline object arguments")
+    }
+    Error(_) -> Nil
+  }
+}
+
+// Test: Generate query with inline array arguments
+pub fn generate_inline_array_arguments_test() {
+  let query_source =
+    "
+    query GetEpisodes {
+      episodesByIds(ids: [1, 2, 3]) {
+        id
+        name
+      }
+    }
+  "
+
+  let assert Ok(operation) = parser.parse(query_source)
+
+  let episode_fields = [
+    schema.Field(
+      "id",
+      schema.NonNullType(schema.NamedType("ID", schema.Scalar)),
+      [],
+      None,
+    ),
+    schema.Field(
+      "name",
+      schema.NonNullType(schema.NamedType("String", schema.Scalar)),
+      [],
+      None,
+    ),
+  ]
+
+  let mock_schema =
+    schema.Schema(
+      Some("Query"),
+      None,
+      None,
+      dict.from_list([
+        #("Episode", schema.ObjectType("Episode", episode_fields, None)),
+        #(
+          "Query",
+          schema.ObjectType(
+            "Query",
+            [
+              schema.Field(
+                "episodesByIds",
+                schema.ListType(schema.NamedType("Episode", schema.Object)),
+                [
+                  schema.InputValue(
+                    "ids",
+                    schema.ListType(schema.NonNullType(schema.NamedType(
+                      "Int",
+                      schema.Scalar,
+                    ))),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+            ],
+            None,
+          ),
+        ),
+      ]),
+    )
+
+  let result =
+    codegen.generate_operation("get_episodes", operation, mock_schema, "")
+
+  case result {
+    Ok(code) -> {
+      code
+      |> birdie.snap(title: "Query with inline array arguments")
+    }
+    Error(_) -> Nil
+  }
+}
+
+// Test: Generate query with multiple root fields and mixed argument types
+pub fn generate_multiple_root_fields_test() {
+  let query_source =
+    "
+    query MultiQuery {
+      characters(page: 2, filter: { name: \"rick\" }) {
+        info {
+          count
+        }
+        results {
+          name
+        }
+      }
+      location(id: 1) {
+        id
+      }
+      episodesByIds(ids: [1, 2]) {
+        id
+      }
+    }
+  "
+
+  let assert Ok(operation) = parser.parse(query_source)
+
+  let character_fields = [
+    schema.Field("name", schema.NamedType("String", schema.Scalar), [], None),
+  ]
+
+  let info_fields = [
+    schema.Field("count", schema.NamedType("Int", schema.Scalar), [], None),
+  ]
+
+  let characters_result_fields = [
+    schema.Field(
+      "info",
+      schema.NamedType("Info", schema.Object),
+      [],
+      None,
+    ),
+    schema.Field(
+      "results",
+      schema.ListType(schema.NamedType("Character", schema.Object)),
+      [],
+      None,
+    ),
+  ]
+
+  let location_fields = [
+    schema.Field("id", schema.NamedType("ID", schema.Scalar), [], None),
+  ]
+
+  let episode_fields = [
+    schema.Field("id", schema.NamedType("ID", schema.Scalar), [], None),
+  ]
+
+  let mock_schema =
+    schema.Schema(
+      Some("Query"),
+      None,
+      None,
+      dict.from_list([
+        #("Character", schema.ObjectType("Character", character_fields, None)),
+        #("Info", schema.ObjectType("Info", info_fields, None)),
+        #(
+          "CharactersResult",
+          schema.ObjectType("CharactersResult", characters_result_fields, None),
+        ),
+        #("Location", schema.ObjectType("Location", location_fields, None)),
+        #("Episode", schema.ObjectType("Episode", episode_fields, None)),
+        #(
+          "Query",
+          schema.ObjectType(
+            "Query",
+            [
+              schema.Field(
+                "characters",
+                schema.NamedType("CharactersResult", schema.Object),
+                [
+                  schema.InputValue(
+                    "page",
+                    schema.NamedType("Int", schema.Scalar),
+                    None,
+                  ),
+                  schema.InputValue(
+                    "filter",
+                    schema.NamedType("FilterInput", schema.InputObject),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+              schema.Field(
+                "location",
+                schema.NamedType("Location", schema.Object),
+                [
+                  schema.InputValue(
+                    "id",
+                    schema.NonNullType(schema.NamedType("ID", schema.Scalar)),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+              schema.Field(
+                "episodesByIds",
+                schema.ListType(schema.NamedType("Episode", schema.Object)),
+                [
+                  schema.InputValue(
+                    "ids",
+                    schema.ListType(schema.NonNullType(schema.NamedType(
+                      "Int",
+                      schema.Scalar,
+                    ))),
+                    None,
+                  ),
+                ],
+                None,
+              ),
+            ],
+            None,
+          ),
+        ),
+      ]),
+    )
+
+  let result =
+    codegen.generate_operation("multi_query", operation, mock_schema, "")
+
+  case result {
+    Ok(code) -> {
+      code
+      |> birdie.snap(title: "Query with multiple root fields and mixed arguments")
+    }
+    Error(_) -> Nil
+  }
+}