format

src/squall.gleam

···
   )
 }
 
+@target(erlang)
 /// Create a new Erlang GraphQL client with custom headers.
 /// This uses the Erlang HTTP adapter (gleam_httpc).
-@target(erlang)
 pub fn new_erlang_client(
   endpoint: String,
   headers: List(#(String, String)),
···
   Client(endpoint: endpoint, headers: headers, send_request: erlang.adapter())
 }
 
-/// Create a new Erlang GraphQL client with bearer token authentication.
 @target(erlang)
+/// Create a new Erlang GraphQL client with bearer token authentication.
 pub fn new_erlang_client_with_auth(endpoint: String, token: String) -> Client {
   Client(
     endpoint: endpoint,
···
   )
 }
 
+@target(javascript)
 /// Create a new JavaScript GraphQL client with custom headers.
 /// This uses the JavaScript HTTP adapter (Fetch API).
-@target(javascript)
 pub fn new_javascript_client(
   endpoint: String,
   headers: List(#(String, String)),
 ) -> Client {
-  Client(endpoint: endpoint, headers: headers, send_request: javascript.adapter())
+  Client(
+    endpoint: endpoint,
+    headers: headers,
+    send_request: javascript.adapter(),
+  )
 }
 
+@target(javascript)
 /// Create a new JavaScript GraphQL client with bearer token authentication.
-@target(javascript)
-pub fn new_javascript_client_with_auth(endpoint: String, token: String) -> Client {
+pub fn new_javascript_client_with_auth(
+  endpoint: String,
+  token: String,
+) -> Client {
   Client(
     endpoint: endpoint,
     headers: [#("Authorization", "Bearer " <> token)],
···
   )
 }
 
+@target(javascript)
 /// Execute a GraphQL query on JavaScript targets.
 /// Returns a Promise that resolves to a Result containing the decoded response.
-@target(javascript)
 pub fn execute_query(
   client: Client,
   query: String,
···
   }
 }
 
+@target(erlang)
 /// Execute a GraphQL query on Erlang targets.
 /// Returns a Result containing the decoded response.
-@target(erlang)
 pub fn execute_query(
   client: Client,
   query: String,

src/squall/adapter.gleam

···
 @target(javascript)
 import gleam/javascript/promise.{type Promise}
 
+@target(erlang)
 /// HTTP adapter function type for Erlang target.
 /// Synchronously returns a Result with Response or error string.
-@target(erlang)
 pub type HttpAdapter =
   fn(Request(String)) -> Result(Response(String), String)
 
+@target(javascript)
 /// HTTP adapter function type for JavaScript target.
 /// Asynchronously returns a Promise containing a Result with Response or error string.
-@target(javascript)
 pub type HttpAdapter =
   fn(Request(String)) -> Promise(Result(Response(String), String))

src/squall/adapter/javascript.gleam

···
 /// This adapter works on both browser and Node.js JavaScript targets.
 /// Returns a Promise that resolves to a Result.
 pub fn adapter() -> adapter.HttpAdapter {
-  fn(req: request.Request(String)) -> Promise(Result(response.Response(String), String)) {
+  fn(req: request.Request(String)) -> Promise(
+    Result(response.Response(String), String),
+  ) {
     fetch.send(req)
     |> promise.try_await(fetch.read_text_body)
     |> promise.map(result.map_error(_, fn(_) { "HTTP request failed" }))

src/squall/internal/codegen.gleam

···
               }
             }
           }
-          let inner_encoder = "fn(list) { json.array(from: list, of: " <> of_fn <> ") }"
+          let inner_encoder =
+            "fn(list) { json.array(from: list, of: " <> of_fn <> ") }"
           call_doc("json.nullable", [
             doc.from_string(field_access),
             doc.from_string(inner_encoder),
···
       // This is an Object type
       case dict.get(schema_types, name) {
         Ok(schema.ObjectType(_, _, _)) ->
-          call_doc(snake_case(name) <> "_to_json", [doc.from_string(field_access)])
+          call_doc(snake_case(name) <> "_to_json", [
+            doc.from_string(field_access),
+          ])
         _ ->
           // Fallback to string if not an object type
           call_doc("json.string", [doc.from_string(field_access)])

test/codegen_test.gleam

···
       [],
       None,
     ),
-    schema.Field(
-      "name",
-      schema.NamedType("String", schema.Scalar),
-      [],
-      None,
-    ),
-    schema.Field(
-      "email",
-      schema.NamedType("String", schema.Scalar),
-      [],
-      None,
-    ),
+    schema.Field("name", schema.NamedType("String", schema.Scalar), [], None),
+    schema.Field("email", schema.NamedType("String", schema.Scalar), [], None),
   ]
 
   let mock_schema =
···
 
   // Create mock schema with nested types
   let location_fields = [
-    schema.Field(
-      "city",
-      schema.NamedType("String", schema.Scalar),
-      [],
-      None,
-    ),
-    schema.Field(
-      "country",
-      schema.NamedType("String", schema.Scalar),
-      [],
-      None,
-    ),
+    schema.Field("city", schema.NamedType("String", schema.Scalar), [], None),
+    schema.Field("country", schema.NamedType("String", schema.Scalar), [], None),
   ]
 
   let user_fields = [
···
       [],
       None,
     ),
-    schema.Field(
-      "metadata",
-      schema.NamedType("JSON", schema.Scalar),
-      [],
-      None,
-    ),
+    schema.Field("metadata", schema.NamedType("JSON", schema.Scalar), [], None),
   ]
 
   let mock_schema =