sans-io

.gitignore

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

CLAUDE.md

···
-# Claude Context: Squall
-
-## Project Overview
-
-**Squall** is a type-safe GraphQL client generator for Gleam, inspired by [squirrel](https://github.com/giacomocavalieri/squirrel). It follows a convention-over-configuration approach where developers write `.gql` files in `src/**/graphql/` directories, and Squall generates fully type-safe Gleam code with proper types and JSON decoders.
-
-## Architecture
-
-### Core Philosophy
-
-1. **Convention over Configuration**: No config files, just drop `.gql` files in the right place
-2. **Type Safety First**: All generated code is fully typed based on GraphQL schema
-3. **Isomorphic by Design**: Generated client code works on any Gleam target (Erlang, JavaScript/Browser, JavaScript/Node)
-4. **Test-Driven Development**: Every feature has tests written first
-5. **Modular Design**: Clear separation of concerns across modules
-
-### Module Breakdown
-
-```
-src/squall/
-├── squall.gleam          # Public API & Client type
-├── adapter.gleam         # HTTP adapter interface
-├── adapter/
-│   ├── erlang.gleam      # Erlang HTTP adapter (uses gleam_httpc)
-│   └── javascript.gleam  # JavaScript HTTP adapter (uses Fetch API)
-└── internal/
-    ├── error.gleam           # Comprehensive error types
-    ├── discovery.gleam       # File discovery and validation
-    ├── parser.gleam          # GraphQL lexer + recursive descent parser
-    ├── schema.gleam          # GraphQL schema introspection
-    ├── type_mapping.gleam    # GraphQL to Gleam type conversion
-    └── codegen.gleam         # Code generation with glam
-```
-
-### Data Flow
-
-```
-.gql files → discovery → parser → type_mapping → codegen → .gleam files
-                ↓
-         schema (from endpoint introspection)
-```
-
-## Key Design Patterns
-
-### 1. Error Handling
-
-All modules use a central `Error` type in `error.gleam`. Errors are:
-- Descriptive with file paths and line numbers where applicable
-- Converted to strings via `error.to_string()` for CLI output
-- Propagated using `Result(T, Error)`
-
-### 2. Type Safety
-
-GraphQL types map to Gleam types:
-- `String`, `Int`, `Float`, `Boolean`, `ID` → Built-in types
-- `Type` (nullable) → `Option(Type)`
-- `Type!` (non-null) → `Type`
-- `[Type]` → `List(Type)`
-- Custom objects → Custom Gleam types
-
-### 3. HTTP Adapter Pattern
-
-**Why Adapters?**
-To make generated code isomorphic (work across Gleam targets), Squall uses an adapter pattern for HTTP requests:
-
-- **`squall.Client`** contains a `send_request: HttpAdapter` field
-- **`HttpAdapter`** is a function type: `fn(Request(String)) -> Result(Response(String), String)`
-- **Platform-specific adapters**:
-  - `squall/adapter/erlang.gleam` - Uses `gleam_httpc` for Erlang target
-  - `squall/adapter/javascript.gleam` - Uses Fetch API for JavaScript targets (browser/Node)
-- **Generated code** calls `client.send_request(req)` instead of directly using `httpc`
-
-**Usage Example:**
-```gleam
-// Erlang target
-import squall
-let client = squall.new_erlang_client("https://api.example.com/graphql", [])
-
-// JavaScript target
-import squall
-let client = squall.new_javascript_client("https://api.example.com/graphql", [])
-
-// Generic (with explicit adapter)
-import squall
-import squall/adapter/erlang
-let client = squall.new_client("https://api.example.com/graphql", [], erlang.adapter())
-```
-
-### 4. Testing Strategy
-
-**TDD Approach:**
-1. Write test first (in `test/` directory)
-2. Run test (it should fail)
-3. Implement feature
-4. Run test (it should pass)
-5. Refactor if needed
-
-**Test Types:**
-- **Unit tests**: Each module has its own test file
-- **Snapshot tests**: Using `birdie` for code generation validation
-- **Integration tests**: Test file embedded in `test/fixtures/graphql/`
-
-### 5. Code Generation
-
-Uses the `glam` library for pretty-printing. Generated code includes:
-- Type definitions (custom types for responses and inputs)
-- JSON decoders (using `gleam/dynamic`)
-- JSON serializers (for converting types back to JSON)
-- HTTP client functions (using `squall.Client` with adapter pattern)
-
-**Key Feature**: Generated code does NOT directly import `gleam_httpc` or any platform-specific HTTP library. Instead, it uses `client.send_request()`, making it work across all Gleam targets.
-
-## File Conventions
-
-### GraphQL Files
-
-- **Location**: `src/**/graphql/*.gql`
-- **Naming**: Filename becomes function name (must be valid Gleam identifier)
-  - ✅ `get_user.gql` → `get_user()`
-  - ✅ `create_post.gql` → `create_post()`
-  - ❌ `get-user.gql` (hyphens not allowed)
-  - ❌ `123user.gql` (can't start with number)
-
-### Generated Files
-
-- **Output**: Same directory as `.gql` file, same name with `.gleam` extension
-- **Pattern**: `src/**/graphql/operation_name.gql` → `src/**/graphql/operation_name.gleam`
-
-## Development Workflow
-
-### Adding a New Feature
-
-1. **Write test first** in appropriate test file
-2. **Run tests**: `gleam test` (should fail)
-3. **Implement feature** in appropriate module
-4. **Run tests**: `gleam test` (should pass)
-5. **Update snapshots if needed**: `BIRDIE_ACCEPT=1 gleam test`
-
-### Testing
-
-```bash
-# Run all tests
-gleam test
-
-# Accept birdie snapshots
-BIRDIE_ACCEPT=1 gleam test
-
-# Build the project
-gleam build
-
-# Run CLI
-gleam run -m squall generate <endpoint>
-```
-
-## Important Implementation Details
-
-### Parser (`parser.gleam`)
-
-- **Two-phase**: Lexer (tokenization) → Parser (AST building)
-- **Recursive descent**: Standard parsing technique
-- **AST Types**: `Operation`, `Selection`, `TypeRef`, `Variable`, `Value`
-- **Handles**: Queries, Mutations, Subscriptions, Variables, Arguments, Nested selections
-
-### Schema (`schema.gleam`)
-
-- **Introspection**: Parses GraphQL introspection JSON
-- **Types**: `Type`, `Field`, `InputValue`, `TypeRef`
-- **Schema**: Contains query/mutation/subscription types + all schema types
-- **Validation**: Checks for required fields, proper structure
-
-### Type Mapping (`type_mapping.gleam`)
-
-- **GleamType**: Internal representation of Gleam types
-- **Conversion**: GraphQL TypeRef → GleamType
-- **Nullable handling**: Automatically wraps nullable types in `Option`
-- **Lists**: Properly handles `[Type]`, `[Type!]`, `[Type]!`, `[Type!]!`
-
-### Code Generation (`codegen.gleam`)
-
-- **Response Types**: Generated for each operation
-- **Decoders**: JSON decoders using `gleam/dynamic`
-- **Functions**: Type-safe functions with proper parameters
-- **Imports**: Automatically includes required imports
-
-## Common Tasks
-
-### Add Support for a New GraphQL Feature
-
-Example: Adding fragment support
-
-1. **Update Parser**:
-   - Add fragment tokens to lexer
-   - Add fragment AST types
-   - Add fragment parsing logic
-
-2. **Update Code Generation**:
-   - Handle fragments in selection sets
-   - Generate fragment helper functions
-
-3. **Write Tests**:
-   ```gleam
-   // In parser_test.gleam
-   pub fn parse_fragment_test() {
-     let source = "fragment UserFields on User { id name }"
-     let result = parser.parse(source)
-     should.be_ok(result)
-   }
-   ```
-
-4. **Add Snapshot Test**:
-   ```gleam
-   // In codegen_test.gleam
-   pub fn generate_with_fragments_test() {
-     // Setup and generate code
-     code |> birdie.snap(title: "Query with fragments")
-   }
-   ```
-
-### Fix a Type Mapping Issue
-
-1. **Locate the issue** in `type_mapping.gleam`
-2. **Write a failing test** in `type_mapping_test.gleam`
-3. **Fix the mapping** logic
-4. **Verify test passes**
-
-### Update Generated Code Format
-
-1. **Modify** `codegen.gleam`
-2. **Run tests**: They will fail with snapshot differences
-3. **Review the diff** to ensure it's correct
-4. **Accept snapshots**: `BIRDIE_ACCEPT=1 gleam test`
-
-## Isomorphic Architecture Benefits
-
-✅ **Achieved:**
-- Generated client code works on Erlang, JavaScript/Browser, and JavaScript/Node
-- No platform-specific imports in generated code
-- Users can easily create custom adapters for other HTTP libraries
-- Generator (CLI) remains Erlang-only (appropriate for build tools)
-
-🎯 **How It Works:**
-1. **Generation Time**: CLI runs on Erlang, uses `gleam_httpc` for schema introspection
-2. **Runtime**: Generated code uses `squall.Client` with platform-specific adapter
-3. **User Code**: Chooses adapter based on target (Erlang vs JavaScript)
-
-## Known Limitations
-
-1. **Fragments**: Not yet implemented
-2. **Directives**: Not yet handled (@include, @skip, etc.)
-3. **Custom Scalars**: Most map to String by default (except JSON which maps to `json.Json`)
-4. **Introspection**: Doesn't handle deeply nested types beyond 5 levels
-5. **JavaScript FFI**: Fetch adapter requires testing on actual JavaScript runtime
-
-## Code Style
-
-### Gleam Conventions
-
-- **Functions**: `snake_case`
-- **Types**: `PascalCase`
-- **Constants**: `snake_case`
-- **Pipes**: Use `|>` for chaining
-- **Pattern Matching**: Prefer `case` over nested `if`
-
-### Project Conventions
-
-- **Naming**: Be descriptive, avoid abbreviations
-- **Comments**: Explain "why" not "what"
-- **Error Messages**: Include file paths and suggestions when possible
-- **Tests**: One test per feature, descriptive test names
-
-## Troubleshooting
-
-### Tests Not Running
-
-- Check `test/squall_test.gleam` - it manually calls all tests
-- Ensure test files don't have their own `main()` functions
-- Test functions must end with `_test`
-
-### Snapshot Tests Failing
-
-- Run `BIRDIE_ACCEPT=1 gleam test` to accept new snapshots
-- Review `.new` files in `birdie_snapshots/` before accepting
-- Snapshots are in `birdie_snapshots/*.accepted`
-
-### Parser Errors
-
-- Check token definitions in `parser.gleam`
-- Ensure lexer handles all GraphQL syntax
-- Test with simple queries first, then complex ones
-
-## Future Improvements
-
-### High Priority
-
-- [ ] Test JavaScript adapter on actual JavaScript runtime (browser & Node.js)
-- [ ] Add fragment support
-- [ ] Handle GraphQL directives
-- [ ] Custom scalar type mapping with user configuration
-
-### Medium Priority
-
-- [ ] Multiple endpoint support
-- [ ] Watch mode for development
-- [ ] Better error messages with source code snippets
-- [ ] Cache schema introspection results
-- [ ] WebSocket adapter for subscriptions
-
-### Low Priority
-
-- [ ] IDE integration
-- [ ] GraphQL validation against schema
-- [ ] Performance optimizations
-- [ ] Parallel file processing
-
-## References
-
-- **Gleam**: https://gleam.run/
-- **Squirrel**: https://github.com/giacomocavalieri/squirrel
-- **GraphQL**: https://graphql.org/
-- **Rick and Morty API**: https://rickandmortyapi.com/graphql (used for testing)
-
-## Questions?
-
-When working on this project:
-
-1. **Follow TDD**: Always write tests first
-2. **Check existing patterns**: Look at similar features for guidance
-3. **Update tests**: If changing behavior, update snapshots
-4. **Ask for context**: Use this document as a starting point
-
-Happy coding! 🌊

README.md

···
-# 🌊 Squall
+# Squall
 
-A type-safe **isomorphic** GraphQL client generator for Gleam.
+A type-safe **sans-io** GraphQL client generator for Gleam.
 
-Squall parses `.gql` files in your project, introspects your GraphQL endpoint, and generates fully type-safe Gleam code that works on **both Erlang and JavaScript** targets. Write your queries once, run them anywhere!
+> This project is in early development and may contain bugs/unsupported GraphQL queries.
 
-> **⚠️ Warning**: This project is in early development and may contain bugs. Also hasn't been published yet.
+## What is Sans-IO?
 
-## Features
+Squall generates functions to **build HTTP requests** and **parse HTTP responses**, but doesn't send them. You control the HTTP layer.
 
-✨ **Isomorphic** - Works on Erlang (backend) and JavaScript (browser/Node.js)
-- Type-safe code generation from GraphQL schema
-- Convention over configuration - `.gql` files in `src/**/graphql/` directories
-- Schema introspection from GraphQL endpoints
-- Supports queries, mutations, and subscriptions
-- Target-specific HTTP adapters (gleam_httpc for Erlang, Fetch API for JavaScript)
-- Client abstraction with authentication and custom headers
+**Benefits:**
+- Works on any Gleam target (Erlang, JavaScript, future targets)
+- Use any HTTP client you want
+- Easy to test without mocking
+- Full control over retries, timeouts, logging
 
 ## Installation
 
-Add squall to your `gleam.toml`:
-
-```toml
-[dependencies]
-squall = "0.1.0"
-
-# If using JavaScript target, also add:
-gleam_javascript = ">= 0.3.0 and < 2.0.0"
+```bash
+gleam add squall
 ```
 
-The `gleam_javascript` dependency provides Promise support needed for async operations on the JavaScript target.
-
 ## Quick Start
 
-### 1. Create a GraphQL query file
-
-Create a file at `src/my_app/graphql/get_character.gql`:
+1. **Create a `.gql` file** at `src/my_app/graphql/get_user.gql`:
 
 ```graphql
-query GetCharacter($id: ID!) {
-  character(id: $id) {
+query GetUser($id: ID!) {
+  user(id: $id) {
     id
     name
-    status
-    species
+    email
   }
 }
 ```
 
-### 2. Generate type-safe code
+2. **Generate code:**
 
 ```bash
-gleam run -m squall generate https://rickandmortyapi.com/graphql
+gleam run -m squall generate https://api.example.com/graphql
 ```
 
-### 3. Use the generated code
+3. **Use it:**
 
 ```gleam
 import squall
-import my_app/graphql/get_character
+import my_app/graphql/get_user
+import gleam/httpc
 
 pub fn main() {
-  // Create a client for your target
-  // On Erlang:
-  let client = squall.new_erlang_client(
-    "https://rickandmortyapi.com/graphql",
-    []
-  )
-
-  // On JavaScript:
-  // let client = squall.new_javascript_client(
-  //   "https://rickandmortyapi.com/graphql",
-  //   []
-  // )
-
-  // Use the generated function - works on both targets!
-  case get_character.get_character(client, "1") {
-    Ok(response) -> {
-      io.println("Character: " <> response.character.name)
-    }
-    Error(err) -> {
-      io.println("Error: " <> err)
-    }
-  }
-}
-```
+  // 1. Create client (just config)
+  let client = squall.new("https://api.example.com/graphql", [])
 
-**Note**: On JavaScript, the generated function returns a `Promise(Result(...))` instead of `Result(...)`. See the [examples](./examples/) for how to handle both targets.
+  // 2. Build request (no I/O)
+  let assert Ok(request) = get_user.get_user(client, "123")
 
-## Creating a Client
+  // 3. Send request (you control this)
+  let assert Ok(response) = httpc.send(request)
 
-Squall provides target-specific client constructors:
+  // 4. Parse response (no I/O)
+  let assert Ok(data) = get_user.parse_get_user_response(response.body)
 
-### Erlang Target
-
-```gleam
-import squall
-
-// Basic client
-let client = squall.new_erlang_client(
-  "https://api.example.com/graphql",
-  [#("X-Custom-Header", "value")]
-)
-
-// With bearer token authentication
-let client = squall.new_erlang_client_with_auth(
-  "https://api.example.com/graphql",
-  "your-api-token-here"
-)
-```
-
-### JavaScript Target
-
-```gleam
-import squall
-
-// Basic client
-let client = squall.new_javascript_client(
-  "https://api.example.com/graphql",
-  [#("X-Custom-Header", "value")]
-)
-
-// With bearer token authentication
-let client = squall.new_javascript_client_with_auth(
-  "https://api.example.com/graphql",
-  "your-api-token-here"
-)
-```
-
-### Isomorphic Code
-
-For code that works on both targets, use `@target()` conditionals:
-
-```gleam
-import squall
-
-@target(erlang)
-fn create_client() -> squall.Client {
-  squall.new_erlang_client("https://api.example.com/graphql", [])
-}
-
-@target(javascript)
-fn create_client() -> squall.Client {
-  squall.new_javascript_client("https://api.example.com/graphql", [])
-}
-
-pub fn main() {
-  let client = create_client()  // Works on both targets!
-  // ... use the client
+  // 5. Use the data
+  io.debug(data.user)
 }
 ```
 
-## Isomorphic Architecture
-
-Squall's isomorphic design means you write your GraphQL queries once, and they work on both Erlang and JavaScript:
-
-### What's Different Between Targets?
-
-| Aspect | Erlang | JavaScript |
-|--------|--------|------------|
-| **HTTP Client** | `gleam_httpc` | Fetch API |
-| **Return Type** | `Result(T, String)` | `Promise(Result(T, String))` |
-| **Execution** | Synchronous | Asynchronous |
-| **Client Constructor** | `new_erlang_client()` | `new_javascript_client()` |
-
-### What's the Same?
-
-✅ **GraphQL queries** - Same `.gql` files
-✅ **Generated types** - Identical response types
-✅ **Generated decoders** - Same JSON parsing logic
-✅ **Business logic** - Share response handling code
-✅ **Generated functions** - Same function signatures (except return type)
-
-The only code you need to write differently is:
-1. Client creation (use `@target()` conditionals)
-2. Promise handling on JavaScript (use `promise.await()`)
-
-Everything else is truly isomorphic!
-
 ## How It Works
 
-Squall follows a simple workflow:
-
-1. **Discovery**: Finds all `.gql` files in `src/**/graphql/` directories
-2. **Parsing**: Parses GraphQL operations (queries, mutations, subscriptions)
-3. **Introspection**: Fetches the GraphQL schema from your endpoint
-4. **Type Mapping**: Maps GraphQL types to Gleam types
-5. **Code Generation**: Generates:
-   - Custom types for responses
-   - JSON decoders
-   - Type-safe functions with proper parameters
-
-## Project Structure
-
-```
-your-project/
-├── src/
-│   └── my_app/
-│       └── graphql/
-│           ├── get_user.gql        # Your GraphQL query
-│           └── get_user.gleam      # Generated code
-└── gleam.toml
-```
-
-## Examples
-
-Check out the [examples](./examples/) directory for complete working examples:
+For each `.gql` file, Squall generates two functions:
 
-- **[01-erlang](./examples/01-erlang/)** - Erlang/OTP backend example
-- **[02-javascript](./examples/02-javascript/)** - JavaScript (Node.js/Browser) example
-- **[03-isomorphic](./examples/03-isomorphic/)** - Cross-platform example that runs on both!
+```gleam
+// Builds HTTP request - no I/O
+pub fn get_user(client: Client, id: String) -> Result(Request(String), String)
 
-## Generated Code
-
-For a query like:
-
-```graphql
-query GetUser($id: ID!) {
-  user(id: $id) {
-    id
-    name
-    email
-  }
-}
+// Parses response - no I/O
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String)
 ```
 
-Squall generates type-safe Gleam code with:
+You send the request with your own HTTP client.
 
-**Response Types:**
-```gleam
-pub type GetUserResponse {
-  GetUserResponse(user: Option(User))
-}
+## JavaScript Target
 
-pub type User {
-  User(
-    id: String,
-    name: Option(String),
-    email: Option(String)
-  )
-}
-```
+Same generated code works on JavaScript. Just use a different HTTP client:
 
-**Decoders:**
 ```gleam
-fn get_user_response_decoder() -> decode.Decoder(GetUserResponse) {
-  // Auto-generated JSON decoder
-}
-```
+import gleam/fetch
+import gleam/javascript/promise
 
-**Query Function:**
-```gleam
-// On Erlang - returns Result
-pub fn get_user(
-  client: squall.Client,
-  id: String,
-) -> Result(GetUserResponse, String) {
-  squall.execute_query(client, query, variables, decoder)
-}
+let client = squall.new("https://api.example.com/graphql", [])
+let assert Ok(request) = get_user.get_user(client, "123")
 
-// On JavaScript - returns Promise(Result)
-pub fn get_user(
-  client: squall.Client,
-  id: String,
-) -> Promise(Result(GetUserResponse, String)) {
-  squall.execute_query(client, query, variables, decoder)
-}
+fetch.send(request)
+|> promise.try_await(fetch.read_text_body)
+|> promise.map(fn(result) {
+  case result {
+    Ok(response) -> {
+      let assert Ok(data) = get_user.parse_get_user_response(response.body)
+      io.debug(data.user)
+    }
+    Error(_) -> io.println("Request failed")
+  }
+})
 ```
 
 ## Type Mapping
···
 
 ## CLI Commands
 
-### Generate Code
-
 ```bash
-# With explicit endpoint
-gleam run -m squall generate https://api.example.com/graphql
+# Generate code
+gleam run -m squall generate <endpoint>
 
-# Using environment variable
-export GRAPHQL_ENDPOINT=https://api.example.com/graphql
-gleam run -m squall generate
+# Example
+gleam run -m squall generate https://rickandmortyapi.com/graphql
 ```
 
-## Architecture
-
-Squall is built with a modular, isomorphic architecture:
-
-### Core Modules
-- **`discovery`**: Finds and reads `.gql` files
-- **`parser`**: Lexes and parses GraphQL operations
-- **`schema`**: Introspects and parses GraphQL schemas
-- **`type_mapping`**: Maps GraphQL types to Gleam types
-- **`codegen`**: Generates platform-agnostic Gleam code
-- **`error`**: Comprehensive error handling
-
-### HTTP Adapter Pattern
-- **`adapter`**: Defines the HTTP adapter interface
-- **`adapter/erlang`**: Erlang implementation using `gleam_httpc`
-- **`adapter/javascript`**: JavaScript implementation using Fetch API
-
-The generated code calls `squall.execute_query()`, which automatically uses the correct HTTP adapter for your target platform.
-
-## Development
+## Examples
 
-### Running Tests
+See the [example/](./example/) directory for a complete working example.
 
-```bash
-gleam test
-```
+## Inspiration
 
-### Project Structure
-
-```
-squall/
-├── src/
-│   ├── squall.gleam                    # CLI entry point & execute_query
-│   └── squall/
-│       ├── adapter.gleam               # HTTP adapter interface
-│       ├── adapter/
-│       │   ├── erlang.gleam           # Erlang HTTP adapter
-│       │   └── javascript.gleam       # JavaScript HTTP adapter
-│       └── internal/
-│           ├── discovery.gleam         # File discovery
-│           ├── parser.gleam            # GraphQL parser
-│           ├── schema.gleam            # Schema introspection
-│           ├── type_mapping.gleam      # Type conversion
-│           ├── codegen.gleam           # Code generation
-│           └── error.gleam             # Error types
-├── test/
-│   ├── discovery_test.gleam
-│   ├── parser_test.gleam
-│   ├── schema_test.gleam
-│   ├── type_mapping_test.gleam
-│   └── codegen_test.gleam
-├── birdie_snapshots/                   # Snapshot tests
-└── examples/                           # Working examples
-    ├── 01-erlang/                     # Erlang example
-    ├── 02-javascript/                 # JavaScript example
-    └── 03-isomorphic/                 # Cross-platform example
-```
+- [bucket](https://github.com/lpil/bucket) - Gleam S3 client with sans-io pattern
+- [squirrel](https://github.com/giacomocavalieri/squirrel) - Original GraphQL client for Gleam
+- [Sans-IO pattern](https://sans-io.readthedocs.io/)
 
 ## Roadmap
 
-### Completed ✅
-- [x] Query support
-- [x] Mutation support
-- [x] Subscription support
-- [x] Type-safe code generation
-- [x] Schema introspection
-- [x] Client abstraction with headers/authentication
-- [x] **Isomorphic support** (Erlang + JavaScript targets)
-- [x] HTTP adapter pattern
-- [x] Target-conditional compilation
-
-### In Progress 🚧
 - [ ] Fragment support
-- [ ] Directive handling (`@include`, `@skip`, etc.)
+- [ ] Directive handling (`@include`, `@skip`)
 - [ ] Custom scalar type mapping
-- [ ] Schema caching for faster regeneration
-
-## Contributing
-
-Contributions are welcome! Please:
-
-1. Follow TDD principles
-2. Add tests for new features
-3. Update snapshots when changing code generation
-4. Follow Gleam style guidelines
+- [ ] Schema caching
 
 ## License
 

birdie_snapshots/mutation_function_generation.accepted

···
 ---
 version: 1.4.1
 title: Mutation function generation
-file: ./test/codegen_test.gleam
-test_name: generate_mutation_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("createUser", json.nullable(input.create_user, user_to_json))])
 }
 
-pub fn create_user(client: squall.Client, name: String) {
-  squall.execute_query(
+pub fn create_user(client: squall.Client, name: String) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "mutation CreateUser($name: String!) { createUser(name: $name) { id name } }",
     json.object([#("name", json.string(name))]),
-    create_user_response_decoder(),
   )
 }
 
+pub fn parse_create_user_response(body: String) -> Result(CreateUserResponse, String) {
+  squall.parse_response(body, create_user_response_decoder())
+}
+

birdie_snapshots/mutation_with_input_object_variable.accepted

···
 ---
 version: 1.4.1
 title: Mutation with InputObject variable
-file: ./test/codegen_test.gleam
-test_name: generate_mutation_with_input_object_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option, Some, None}
···
   )
 }
 
-pub fn update_profile(client: squall.Client, input: ProfileInput) {
-  squall.execute_query(
+pub fn update_profile(client: squall.Client, input: ProfileInput) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "mutation UpdateProfile($input: ProfileInput!) { updateProfile(input: $input) { id displayName } }",
     json.object([#("input", profile_input_to_json(input))]),
-    update_profile_response_decoder(),
   )
 }
 
+pub fn parse_update_profile_response(body: String) -> Result(UpdateProfileResponse, String) {
+  squall.parse_response(body, update_profile_response_decoder())
+}
+

birdie_snapshots/mutation_with_json_scalar_in_input_object.accepted

···
 ---
 version: 1.4.1
 title: Mutation with JSON scalar in InputObject
-file: ./test/codegen_test.gleam
-test_name: generate_mutation_with_json_input_field_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option, Some, None}
···
   )
 }
 
-pub fn update_settings(client: squall.Client, input: SettingsInput) {
-  squall.execute_query(
+pub fn update_settings(client: squall.Client, input: SettingsInput) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "mutation UpdateSettings($input: SettingsInput!) { updateSettings(input: $input) { id metadata } }",
     json.object([#("input", settings_input_to_json(input))]),
-    update_settings_response_decoder(),
   )
 }
 
+pub fn parse_update_settings_response(body: String) -> Result(UpdateSettingsResponse, String) {
+  squall.parse_response(body, update_settings_response_decoder())
+}
+

birdie_snapshots/mutation_with_nested_input_object_types.accepted

···
 ---
 version: 1.4.1
 title: Mutation with nested InputObject types
-file: ./test/codegen_test.gleam
-test_name: generate_mutation_with_nested_input_object_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option, Some, None}
···
   )
 }
 
-pub fn update_profile(client: squall.Client, input: ProfileInput) {
-  squall.execute_query(
+pub fn update_profile(client: squall.Client, input: ProfileInput) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "mutation UpdateProfile($input: ProfileInput!) { updateProfile(input: $input) { id displayName } }",
     json.object([#("input", profile_input_to_json(input))]),
-    update_profile_response_decoder(),
   )
 }
 
+pub fn parse_update_profile_response(body: String) -> Result(UpdateProfileResponse, String) {
+  squall.parse_response(body, update_profile_response_decoder())
+}
+

birdie_snapshots/mutation_with_optional_input_object_fields_(imports_some,_none).accepted

···
 ---
 version: 1.4.1
 title: Mutation with optional InputObject fields (imports Some, None)
-file: ./test/codegen_test.gleam
-test_name: generate_mutation_with_optional_input_fields_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option, Some, None}
···
   )
 }
 
-pub fn create_profile(client: squall.Client, input: ProfileInput) {
-  squall.execute_query(
+pub fn create_profile(client: squall.Client, input: ProfileInput) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "mutation CreateProfile($input: ProfileInput!) { createProfile(input: $input) { id displayName description } }",
     json.object([#("input", profile_input_to_json(input))]),
-    create_profile_response_decoder(),
   )
 }
 
+pub fn parse_create_profile_response(body: String) -> Result(CreateProfileResponse, String) {
+  squall.parse_response(body, create_profile_response_decoder())
+}
+

birdie_snapshots/query_with_all_non_nullable_fields_(no_option_import).accepted

···
 ---
 version: 1.4.1
 title: Query with all non-nullable fields (no Option import)
-file: ./test/codegen_test.gleam
-test_name: generate_query_with_all_non_nullable_fields_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 
···
   json.object([#("product", product_to_json(input.product))])
 }
 
-pub fn get_product(client: squall.Client) {
-  squall.execute_query(
+pub fn get_product(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetProduct { product { id name price } }",
     json.object([]),
-    get_product_response_decoder(),
   )
 }
 
+pub fn parse_get_product_response(body: String) -> Result(GetProductResponse, String) {
+  squall.parse_response(body, get_product_response_decoder())
+}
+

birdie_snapshots/query_with_inline_array_arguments.accepted

···
 ---
 version: 1.4.1
 title: Query with inline array arguments
-file: ./test/codegen_test.gleam
-test_name: generate_inline_array_arguments_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn get_episodes(client: squall.Client) {
-  squall.execute_query(
+pub fn get_episodes(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetEpisodes { episodesByIds(ids: [1, 2, 3]) { id name } }",
     json.object([]),
-    get_episodes_response_decoder(),
   )
 }
 
+pub fn parse_get_episodes_response(body: String) -> Result(GetEpisodesResponse, String) {
+  squall.parse_response(body, get_episodes_response_decoder())
+}
+

birdie_snapshots/query_with_inline_object_arguments.accepted

···
 ---
 version: 1.4.1
 title: Query with inline object arguments
-file: ./test/codegen_test.gleam
-test_name: generate_inline_object_arguments_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn get_characters(client: squall.Client) {
-  squall.execute_query(
+pub fn get_characters(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetCharacters { characters(filter: { name: \"rick\", status: \"alive\" }) { results { id name } } }",
     json.object([]),
-    get_characters_response_decoder(),
   )
 }
 
+pub fn parse_get_characters_response(body: String) -> Result(GetCharactersResponse, String) {
+  squall.parse_response(body, get_characters_response_decoder())
+}
+

birdie_snapshots/query_with_inline_scalar_arguments.accepted

···
 ---
 version: 1.4.1
 title: Query with inline scalar arguments
-file: ./test/codegen_test.gleam
-test_name: generate_inline_scalar_arguments_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn get_character(client: squall.Client) {
-  squall.execute_query(
+pub fn get_character(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetCharacter { character(id: 1) { id name } }",
     json.object([]),
-    get_character_response_decoder(),
   )
 }
 
+pub fn parse_get_character_response(body: String) -> Result(GetCharacterResponse, String) {
+  squall.parse_response(body, get_character_response_decoder())
+}
+

birdie_snapshots/query_with_json_scalar_field.accepted

···
 ---
 version: 1.4.1
 title: Query with JSON scalar field
-file: ./test/codegen_test.gleam
-test_name: generate_query_with_json_scalar_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("profile", json.nullable(input.profile, profile_to_json))])
 }
 
-pub fn get_profile(client: squall.Client) {
-  squall.execute_query(
+pub fn get_profile(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetProfile { profile { id displayName metadata } }",
     json.object([]),
-    get_profile_response_decoder(),
   )
 }
 
+pub fn parse_get_profile_response(body: String) -> Result(GetProfileResponse, String) {
+  squall.parse_response(body, get_profile_response_decoder())
+}
+

birdie_snapshots/query_with_multiple_root_fields_and_mixed_arguments.accepted

···
 ---
 version: 1.4.1
 title: Query with multiple root fields and mixed arguments
-file: ./test/codegen_test.gleam
-test_name: generate_multiple_root_fields_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn multi_query(client: squall.Client) {
-  squall.execute_query(
+pub fn multi_query(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }",
     json.object([]),
-    multi_query_response_decoder(),
   )
 }
 
+pub fn parse_multi_query_response(body: String) -> Result(MultiQueryResponse, String) {
+  squall.parse_response(body, multi_query_response_decoder())
+}
+

birdie_snapshots/query_with_nested_types_generation.accepted

···
 ---
 version: 1.4.1
 title: Query with nested types generation
-file: ./test/codegen_test.gleam
-test_name: generate_query_with_nested_types_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn get_character(client: squall.Client, id: String) {
-  squall.execute_query(
+pub fn get_character(client: squall.Client, id: String) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetCharacter($id: ID!) { character(id: $id) { id name status } }",
     json.object([#("id", json.string(id))]),
-    get_character_response_decoder(),
   )
 }
 
+pub fn parse_get_character_response(body: String) -> Result(GetCharacterResponse, String) {
+  squall.parse_response(body, get_character_response_decoder())
+}
+

birdie_snapshots/query_with_optional_response_fields_(no_some,_none_imports).accepted

···
 ---
 version: 1.4.1
 title: Query with optional response fields (no Some, None imports)
-file: ./test/codegen_test.gleam
-test_name: generate_query_with_optional_response_fields_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("profile", json.nullable(input.profile, profile_to_json))])
 }
 
-pub fn get_profile(client: squall.Client) {
-  squall.execute_query(
+pub fn get_profile(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetProfile { profile { id displayName description } }",
     json.object([]),
-    get_profile_response_decoder(),
   )
 }
 
+pub fn parse_get_profile_response(body: String) -> Result(GetProfileResponse, String) {
+  squall.parse_response(body, get_profile_response_decoder())
+}
+

birdie_snapshots/query_with_variables_function_generation.accepted

···
 ---
 version: 1.4.1
 title: Query with variables function generation
-file: ./test/codegen_test.gleam
-test_name: generate_query_with_variables_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("user", json.nullable(input.user, user_to_json))])
 }
 
-pub fn get_user(client: squall.Client, id: String) {
-  squall.execute_query(
+pub fn get_user(client: squall.Client, id: String) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUser($id: ID!) { user(id: $id) { id name } }",
     json.object([#("id", json.string(id))]),
-    get_user_response_decoder(),
   )
 }
 
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String) {
+  squall.parse_response(body, get_user_response_decoder())
+}
+

birdie_snapshots/response_serializer_for_simple_type.accepted

···
 ---
 version: 1.4.1
 title: Response serializer for simple type
-file: ./test/codegen_test.gleam
-test_name: generate_response_serializer_simple_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("user", json.nullable(input.user, user_to_json))])
 }
 
-pub fn get_user(client: squall.Client) {
-  squall.execute_query(
+pub fn get_user(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUser { user { id name } }",
     json.object([]),
-    get_user_response_decoder(),
   )
 }
 
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String) {
+  squall.parse_response(body, get_user_response_decoder())
+}
+

birdie_snapshots/response_serializer_with_all_scalar_types.accepted

···
 ---
 version: 1.4.1
 title: Response serializer with all scalar types
-file: ./test/codegen_test.gleam
-test_name: generate_response_serializer_with_all_scalars_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("product", json.nullable(input.product, product_to_json))])
 }
 
-pub fn get_product(client: squall.Client) {
-  squall.execute_query(
+pub fn get_product(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetProduct { product { id name price inStock rating metadata } }",
     json.object([]),
-    get_product_response_decoder(),
   )
 }
 
+pub fn parse_get_product_response(body: String) -> Result(GetProductResponse, String) {
+  squall.parse_response(body, get_product_response_decoder())
+}
+

birdie_snapshots/response_serializer_with_lists.accepted

···
 ---
 version: 1.4.1
 title: Response serializer with lists
-file: ./test/codegen_test.gleam
-test_name: generate_response_serializer_with_lists_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   )
 }
 
-pub fn get_users(client: squall.Client) {
-  squall.execute_query(
+pub fn get_users(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUsers { users { id name } }",
     json.object([]),
-    get_users_response_decoder(),
   )
 }
 
+pub fn parse_get_users_response(body: String) -> Result(GetUsersResponse, String) {
+  squall.parse_response(body, get_users_response_decoder())
+}
+

birdie_snapshots/response_serializer_with_nested_types.accepted

···
 ---
 version: 1.4.1
 title: Response serializer with nested types
-file: ./test/codegen_test.gleam
-test_name: generate_response_serializer_with_nested_types_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("user", json.nullable(input.user, user_to_json))])
 }
 
-pub fn get_user(client: squall.Client) {
-  squall.execute_query(
+pub fn get_user(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUser { user { id name location { city country } } }",
     json.object([]),
-    get_user_response_decoder(),
   )
 }
 
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String) {
+  squall.parse_response(body, get_user_response_decoder())
+}
+

birdie_snapshots/response_serializer_with_optional_fields.accepted

···
 ---
 version: 1.4.1
 title: Response serializer with optional fields
-file: ./test/codegen_test.gleam
-test_name: generate_response_serializer_with_optional_fields_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("user", json.nullable(input.user, user_to_json))])
 }
 
-pub fn get_user(client: squall.Client) {
-  squall.execute_query(
+pub fn get_user(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUser { user { id name email } }",
     json.object([]),
-    get_user_response_decoder(),
   )
 }
 
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String) {
+  squall.parse_response(body, get_user_response_decoder())
+}
+

birdie_snapshots/simple_query_function_generation.accepted

···
 ---
 version: 1.4.1
 title: Simple query function generation
-file: ./test/codegen_test.gleam
-test_name: generate_simple_query_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("user", json.nullable(input.user, user_to_json))])
 }
 
-pub fn get_user(client: squall.Client) {
-  squall.execute_query(
+pub fn get_user(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetUser { user { id name } }",
     json.object([]),
-    get_user_response_decoder(),
   )
 }
 
+pub fn parse_get_user_response(body: String) -> Result(GetUserResponse, String) {
+  squall.parse_response(body, get_user_response_decoder())
+}
+

birdie_snapshots/type_with_reserved_keywords.accepted

···
 ---
 version: 1.4.1
 title: Type with reserved keywords
-file: ./test/codegen_test.gleam
-test_name: generate_with_reserved_keywords_test
 ---
 import gleam/dynamic/decode
+import gleam/http/request.{type Request}
 import gleam/json
 import squall
 import gleam/option.{type Option}
···
   json.object([#("item", json.nullable(input.item, item_to_json))])
 }
 
-pub fn get_item(client: squall.Client) {
-  squall.execute_query(
+pub fn get_item(client: squall.Client) -> Result(Request(String), String) {
+  squall.prepare_request(
     client,
     "query GetItem { item { id type case let } }",
     json.object([]),
-    get_item_response_decoder(),
   )
 }
 
+pub fn parse_get_item_response(body: String) -> Result(GetItemResponse, String) {
+  squall.parse_response(body, get_item_response_decoder())
+}
+

example/README.md

···
+# example
+
+```sh
+gleam run   # Run the project
+```

example/gleam.toml

···
+name = "example"
+version = "1.0.0"
+
+[dependencies]
+gleam_stdlib = ">= 0.34.0 and < 2.0.0"
+gleam_json = ">= 3.0.0 and < 4.0.0"
+gleam_http = ">= 4.3.0 and < 5.0.0"
+squall = { path = "../" }
+
+# For Erlang target (default)
+gleam_httpc = ">= 5.0.0 and < 6.0.0"
+
+# For JavaScript target: comment out httpc above and uncomment this
+# gleam_fetch = ">= 1.0.0 and < 2.0.0"
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"

example/src/example.gleam

···
+import gleam/http/request
+import gleam/io
+import gleam/result
+
+import squall
+
+// Import the generated GraphQL code
+import graphql/get_character
+
+// For Erlang target (default)
+import gleam/httpc
+
+// For JavaScript target: comment out httpc above and uncomment these
+// import gleam/javascript/promise
+// import gleam/fetch
+
+pub fn main() {
+  let client = squall.new("https://rickandmortyapi.com/graphql", [])
+  let assert Ok(request) = get_character.get_character(client, "1")
+  let assert Ok(body) = send_erlang(request)
+  io.println(body)
+}
+
+// ==================== ERLANG HTTP CLIENT ====================
+fn send_erlang(request: request.Request(String)) -> Result(String, String) {
+  httpc.send(request)
+  |> result.map(fn(resp) { resp.body })
+  |> result.map_error(fn(_) { "HTTP request failed" })
+}
+// ==================== JAVASCRIPT HTTP CLIENT ====================
+// Uncomment this function when using JavaScript target
+//
+// fn send_javascript(
+//   request: Request(String),
+// ) -> promise.Promise(Result(String, String)) {
+//   fetch.send(request)
+//   |> promise.try_await(fetch.read_text_body)
+//   |> promise.map(fn(result) {
+//     result
+//     |> result.map(fn(resp) { resp.body })
+//     |> result.map_error(fn(_) { "HTTP request failed" })
+//   })
+// }

example/src/graphql/get_character.gleam

···
+import gleam/dynamic/decode
+import gleam/http/request.{type Request}
+import gleam/json
+import gleam/option.{type Option}
+import squall
+
+pub type Character {
+  Character(
+    id: Option(String),
+    name: Option(String),
+    status: Option(String),
+    species: Option(String),
+  )
+}
+
+pub fn character_decoder() -> decode.Decoder(Character) {
+  use id <- decode.field("id", decode.optional(decode.string))
+  use name <- decode.field("name", decode.optional(decode.string))
+  use status <- decode.field("status", decode.optional(decode.string))
+  use species <- decode.field("species", decode.optional(decode.string))
+  decode.success(Character(id: id, name: name, status: status, species: species))
+}
+
+pub fn character_to_json(input: Character) -> json.Json {
+  json.object([
+    #("id", json.nullable(input.id, json.string)),
+    #("name", json.nullable(input.name, json.string)),
+    #("status", json.nullable(input.status, json.string)),
+    #("species", json.nullable(input.species, json.string)),
+  ])
+}
+
+pub type GetCharacterResponse {
+  GetCharacterResponse(character: Option(Character))
+}
+
+pub fn get_character_response_decoder() -> decode.Decoder(GetCharacterResponse) {
+  use character <- decode.field(
+    "character",
+    decode.optional(character_decoder()),
+  )
+  decode.success(GetCharacterResponse(character: character))
+}
+
+pub fn get_character_response_to_json(input: GetCharacterResponse) -> json.Json {
+  json.object([
+    #("character", json.nullable(input.character, character_to_json)),
+  ])
+}
+
+pub fn get_character(
+  client: squall.Client,
+  id: String,
+) -> Result(Request(String), String) {
+  squall.prepare_request(
+    client,
+    "query GetCharacter($id: ID!) { character(id: $id) { id name status species } }",
+    json.object([#("id", json.string(id))]),
+  )
+}
+
+pub fn parse_get_character_response(
+  body: String,
+) -> Result(GetCharacterResponse, String) {
+  squall.parse_response(body, get_character_response_decoder())
+}

examples/01-erlang/README.md

···
-# Squall Erlang Example
-
-This example demonstrates using Squall-generated GraphQL clients on the **Erlang/OTP** target.
-
-## What's Inside
-
-- `erlang_example.gleam` - Multi-field query example
-- `example_with_vars.gleam` - Query with GraphQL variables
-- `src/graphql/*.gql` - GraphQL query definitions
-- `src/graphql/*.gleam` - Generated type-safe Gleam code
-
-## HTTP Adapter
-
-This example uses the **Erlang adapter** which uses `gleam_httpc` for HTTP requests:
-
-```gleam
-import squall
-
-let client = squall.new_erlang_client("https://rickandmortyapi.com/graphql", [])
-```
-
-## Running
-
-```bash
-# Build the project
-gleam build
-
-# Run the main example
-gleam run -m erlang_example
-
-# Run the variables example
-gleam run -m example_with_vars
-```
-
-## Regenerating GraphQL Code
-
-If you modify the `.gql` files, regenerate the code:
-
-```bash
-# From the squall root directory
-cd ../..
-gleam run -m squall generate https://rickandmortyapi.com/graphql
-```
-
-This will update the `.gleam` files in `src/graphql/`.
-
-## Features Demonstrated
-
-✅ **Erlang/OTP Runtime** - Uses `gleam_httpc` HTTP client
-✅ **Type Safety** - Fully typed based on GraphQL schema
-✅ **Nested Objects** - Automatic decoder generation
-✅ **Optional Fields** - Proper `Option` type handling
-✅ **Variables** - Type-safe GraphQL variables
-✅ **JSON Serialization** - Convert responses back to JSON

examples/01-erlang/gleam.toml

···
-name = "erlang_example"
-version = "0.1.0"
-description = "Squall Erlang example - Rick and Morty GraphQL API"
-
-[dependencies]
-gleam_stdlib = ">= 0.65.0 and < 0.66.0"
-gleam_json = ">= 3.0.0 and < 4.0.0"
-gleam_http = ">= 4.3.0 and < 5.0.0"
-squall = { path = "../.." }

examples/01-erlang/manifest.toml example/manifest.toml

···
   { name = "gleam_javascript", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_javascript", source = "hex", outer_checksum = "EF6C77A506F026C6FB37941889477CD5E4234FCD4337FF0E9384E297CB8F97EB" },
   { name = "gleam_json", version = "3.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "874FA3C3BB6E22DD2BB111966BD40B3759E9094E05257899A7C08F5DE77EC049" },
   { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
-  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
-  { name = "squall", version = "0.1.0", build_tools = ["gleam"], requirements = ["argv", "filepath", "glam", "gleam_fetch", "gleam_http", "gleam_httpc", "gleam_json", "gleam_stdlib", "simplifile"], source = "local", path = "../.." },
+  { name = "gleeunit", version = "1.9.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "DA9553CE58B67924B3C631F96FE3370C49EB6D6DC6B384EC4862CC4AAA718F3C" },
+  { name = "simplifile", version = "2.3.1", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "957E0E5B75927659F1D2A1B7B75D7B9BA96FAA8D0C53EA71C4AD9CD0C6B848F6" },
+  { name = "squall", version = "0.1.0", build_tools = ["gleam"], requirements = ["argv", "filepath", "glam", "gleam_fetch", "gleam_http", "gleam_httpc", "gleam_javascript", "gleam_json", "gleam_stdlib", "simplifile", "swell"], source = "local", path = ".." },
+  { name = "swell", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "swell", source = "hex", outer_checksum = "7CCA8C61349396C5B59B3C0627185F5B30917044E0D61CB7E0E5CC75C1B4A8E9" },
 ]
 
 [requirements]
-gleam_fetch = { version = ">= 1.0.0 and < 2.0.0" }
 gleam_http = { version = ">= 4.3.0 and < 5.0.0" }
-gleam_javascript = { version = ">= 0.3.0 and < 2.0.0" }
+gleam_httpc = { version = ">= 5.0.0 and < 6.0.0" }
 gleam_json = { version = ">= 3.0.0 and < 4.0.0" }
-gleam_stdlib = { version = ">= 0.65.0 and < 0.66.0" }
-squall = { path = "../.." }
+gleam_stdlib = { version = ">= 0.34.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
+squall = { path = "../" }

examples/01-erlang/src/erlang_example.gleam

···
-import gleam/io
-import gleam/json
-import gleam/string
-import graphql/multi_query
-import squall
-
-pub fn main() {
-  io.println("Squall Multi-Field Query Example (Erlang)")
-  io.println("==========================================\n")
-
-  // Create an Erlang client (uses gleam_httpc for HTTP requests)
-  let client = squall.new_erlang_client("https://rickandmortyapi.com/graphql", [])
-
-  let result = multi_query.multi_query(client)
-
-  case result {
-    Ok(response) -> {
-      io.println("✓ Success! Received response from API\n")
-
-      // Print the Gleam data structure
-      io.println("Gleam Response Structure:")
-      io.println("-------------------------")
-      io.println(string.inspect(response))
-
-      // Convert to JSON and print
-      io.println("\nJSON Response:")
-      io.println("--------------")
-      let json_response = multi_query.multi_query_response_to_json(response)
-      io.println(json.to_string(json_response))
-
-      Nil
-    }
-    Error(err) -> {
-      io.println("✗ Error: " <> err)
-      Nil
-    }
-  }
-}

examples/01-erlang/src/example_with_vars.gleam

···
-import gleam/io
-import gleam/json
-import gleam/string
-import graphql/multi_query_with_vars
-import squall
-
-pub fn main() {
-  io.println("Squall Multi-Field Query Example (with Variables - Erlang)")
-  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")
-
-  // Create an Erlang client (uses gleam_httpc for HTTP requests)
-  let client = squall.new_erlang_client("https://rickandmortyapi.com/graphql", [])
-
-  let result =
-    multi_query_with_vars.multi_query_with_vars(client, 2, "rick", "1", [1, 2])
-
-  case result {
-    Ok(response) -> {
-      io.println("✓ Success! Received response from API\n")
-
-      // Print the Gleam data structure
-      io.println("Gleam Response Structure:")
-      io.println("-------------------------")
-      io.println(string.inspect(response))
-
-      // Convert to JSON and print
-      io.println("\nJSON Response:")
-      io.println("--------------")
-      let json_response =
-        multi_query_with_vars.multi_query_with_vars_response_to_json(response)
-      io.println(json.to_string(json_response))
-
-      Nil
-    }
-    Error(err) -> {
-      io.println("✗ Error: " <> err)
-      Nil
-    }
-  }
-}

examples/01-erlang/src/graphql/get_character.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-    type_: Option(String),
-    gender: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  use type_ <- decode.field("type", decode.optional(decode.string))
-  use gender <- decode.field("gender", decode.optional(decode.string))
-  decode.success(Character(
-    id: id,
-    name: name,
-    status: status,
-    species: species,
-    type_: type_,
-    gender: gender,
-  ))
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-      #("type", json.nullable(input.type_, json.string)),
-      #("gender", json.nullable(input.gender, json.string)),
-    ],
-  )
-}
-
-pub type GetCharacterResponse {
-  GetCharacterResponse(character: Option(Character))
-}
-
-pub fn get_character_response_decoder() -> decode.Decoder(GetCharacterResponse) {
-  use character <- decode.field("character", decode.optional(character_decoder()))
-  decode.success(GetCharacterResponse(character: character))
-}
-
-pub fn get_character_response_to_json(input: GetCharacterResponse) -> json.Json {
-  json.object(
-    [
-      #("character", json.nullable(input.character, character_to_json)),
-    ],
-  )
-}
-
-pub fn get_character(client: squall.Client, id: String) {
-  squall.execute_query(
-    client,
-    "query GetCharacter($id: ID!) { character(id: $id) { id name status species type gender } }",
-    json.object([#("id", json.string(id))]),
-    get_character_response_decoder(),
-  )
-}

examples/01-erlang/src/graphql/get_character.gql example/src/graphql/get_character.gql

···
     name
     status
     species
-    type
-    gender
   }
 }

examples/01-erlang/src/graphql/get_characters.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(results: results))
-}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  decode.success(Character(id: id, name: name, status: status, species: species))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-    ],
-  )
-}
-
-pub type GetCharactersResponse {
-  GetCharactersResponse(characters: Option(Characters))
-}
-
-pub fn get_characters_response_decoder() -> decode.Decoder(GetCharactersResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  decode.success(GetCharactersResponse(characters: characters))
-}
-
-pub fn get_characters_response_to_json(input: GetCharactersResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-    ],
-  )
-}
-
-pub fn get_characters(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query GetCharacters { characters { results { id name status species } } }",
-    json.object([]),
-    get_characters_response_decoder(),
-  )
-}

examples/01-erlang/src/graphql/get_characters.gql

···
-query GetCharacters {
-  characters {
-    results {
-      id
-      name
-      status
-      species
-    }
-  }
-}

examples/01-erlang/src/graphql/multi_query.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Location(id: id))
-}
-
-pub type Episode {
-  Episode(id: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Episode(id: id))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub type MultiQueryResponse {
-  MultiQueryResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_response_decoder() -> decode.Decoder(MultiQueryResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_response_to_json(input: MultiQueryResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }",
-    json.object([]),
-    multi_query_response_decoder(),
-  )
-}

examples/01-erlang/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
-  }
-}

examples/01-erlang/src/graphql/multi_query_with_vars.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String), name: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Location(id: id, name: name))
-}
-
-pub type Episode {
-  Episode(id: Option(String), name: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Episode(id: id, name: name))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub type MultiQueryWithVarsResponse {
-  MultiQueryWithVarsResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_with_vars_response_decoder() -> decode.Decoder(MultiQueryWithVarsResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryWithVarsResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_with_vars_response_to_json(input: MultiQueryWithVarsResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query_with_vars(client: squall.Client, page: Int, name: String, location_id: String, episode_ids: List(Int)) {
-  squall.execute_query(
-    client,
-    "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 } }",
-    json.object(
-      [
-        #("page", json.int(page)),
-        #("name", json.string(name)),
-        #("locationId", json.string(location_id)),
-        #("episodeIds", json.array(from: episode_ids, of: json.int)),
-      ],
-    ),
-    multi_query_with_vars_response_decoder(),
-  )
-}

examples/01-erlang/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
-  }
-}

examples/02-javascript/README.md

···
-# Squall JavaScript Example
-
-This example demonstrates using Squall-generated GraphQL clients on the **JavaScript** target (Node.js or browser).
-
-## What's Inside
-
-- `javascript_example.gleam` - Multi-field query example using Fetch API
-- `src/graphql/*.gql` - GraphQL query definitions
-- `src/graphql/*.gleam` - Generated type-safe Gleam code (same as Erlang!)
-
-## HTTP Adapter
-
-This example uses the **JavaScript adapter** which uses the Fetch API for HTTP requests:
-
-```gleam
-import squall
-
-let client = squall.new_javascript_client("https://rickandmortyapi.com/graphql", [])
-```
-
-The Fetch API works in:
-- **Node.js** v18+ (built-in)
-- **Browsers** (all modern browsers)
-- **Deno** (built-in)
-
-## Running
-
-### Node.js (Recommended)
-
-```bash
-# Build for JavaScript target
-gleam build
-
-# Run the example
-gleam run -m javascript_example
-```
-
-### Browser
-
-1. Build the JavaScript bundle:
-   ```bash
-   gleam build --target javascript
-   ```
-
-2. The compiled JavaScript will be in `build/dev/javascript/`
-
-3. Include it in an HTML file or use with a bundler (Vite, Webpack, etc.)
-
-## Requirements
-
-- **Node.js** v18.0.0 or later (for native Fetch API support)
-- Or any modern browser
-
-## Regenerating GraphQL Code
-
-If you modify the `.gql` files, regenerate the code:
-
-```bash
-# From the squall root directory
-cd ../..
-gleam run -m squall generate https://rickandmortyapi.com/graphql
-```
-
-This will update the `.gleam` files in `src/graphql/`.
-
-## Key Differences from Erlang Example
-
-The **only difference** between this and the Erlang example is the client creation:
-
-```gleam
-// JavaScript
-squall.new_javascript_client(endpoint, headers)
-
-// vs Erlang
-squall.new_erlang_client(endpoint, headers)
-```
-
-**Everything else is identical!** The same generated GraphQL code works on both targets.
-
-## Features Demonstrated
-
-✅ **JavaScript Runtime** - Uses Fetch API (Node.js/Browser)
-✅ **Type Safety** - Fully typed based on GraphQL schema
-✅ **Isomorphic Code** - Same generated code as Erlang example
-✅ **Nested Objects** - Automatic decoder generation
-✅ **Optional Fields** - Proper `Option` type handling
-✅ **JSON Serialization** - Convert responses back to JSON

examples/02-javascript/gleam.toml

···
-name = "javascript_example"
-version = "0.1.0"
-description = "Squall JavaScript example - Rick and Morty GraphQL API"
-target = "javascript"
-
-[dependencies]
-gleam_stdlib = ">= 0.65.0 and < 0.66.0"
-gleam_json = ">= 3.0.0 and < 4.0.0"
-gleam_http = ">= 4.3.0 and < 5.0.0"
-gleam_javascript = ">= 0.3.0 and < 2.0.0"
-squall = { path = "../.." }
-
-[javascript]
-runtime = "node"

examples/02-javascript/manifest.toml

···
-# This file was generated by Gleam
-# You typically do not need to edit this file
-
-packages = [
-  { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
-  { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
-  { name = "glam", version = "2.0.3", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glam", source = "hex", outer_checksum = "237C2CE218A2A0A5D46D625F8EF5B78F964BC91018B78D692B17E1AB84295229" },
-  { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
-  { name = "gleam_fetch", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_http", "gleam_javascript", "gleam_stdlib"], otp_app = "gleam_fetch", source = "hex", outer_checksum = "2CBF9F2E1C71AEBBFB13A9D5720CD8DB4263EB02FE60C5A7A1C6E17B0151C20C" },
-  { name = "gleam_http", version = "4.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_http", source = "hex", outer_checksum = "82EA6A717C842456188C190AFB372665EA56CE13D8559BF3B1DD9E40F619EE0C" },
-  { name = "gleam_httpc", version = "5.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_http", "gleam_stdlib"], otp_app = "gleam_httpc", source = "hex", outer_checksum = "C545172618D07811494E97AAA4A0FB34DA6F6D0061FDC8041C2F8E3BE2B2E48F" },
-  { name = "gleam_javascript", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_javascript", source = "hex", outer_checksum = "EF6C77A506F026C6FB37941889477CD5E4234FCD4337FF0E9384E297CB8F97EB" },
-  { name = "gleam_json", version = "3.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "874FA3C3BB6E22DD2BB111966BD40B3759E9094E05257899A7C08F5DE77EC049" },
-  { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
-  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
-  { name = "squall", version = "0.1.0", build_tools = ["gleam"], requirements = ["argv", "filepath", "glam", "gleam_fetch", "gleam_http", "gleam_httpc", "gleam_json", "gleam_stdlib", "simplifile"], source = "local", path = "../.." },
-]
-
-[requirements]
-gleam_http = { version = ">= 4.3.0 and < 5.0.0" }
-gleam_javascript = { version = ">= 0.3.0 and < 2.0.0" }
-gleam_json = { version = ">= 3.0.0 and < 4.0.0" }
-gleam_stdlib = { version = ">= 0.65.0 and < 0.66.0" }
-squall = { path = "../.." }

examples/02-javascript/src/graphql/get_character.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-    type_: Option(String),
-    gender: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  use type_ <- decode.field("type", decode.optional(decode.string))
-  use gender <- decode.field("gender", decode.optional(decode.string))
-  decode.success(Character(
-    id: id,
-    name: name,
-    status: status,
-    species: species,
-    type_: type_,
-    gender: gender,
-  ))
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-      #("type", json.nullable(input.type_, json.string)),
-      #("gender", json.nullable(input.gender, json.string)),
-    ],
-  )
-}
-
-pub type GetCharacterResponse {
-  GetCharacterResponse(character: Option(Character))
-}
-
-pub fn get_character_response_decoder() -> decode.Decoder(GetCharacterResponse) {
-  use character <- decode.field("character", decode.optional(character_decoder()))
-  decode.success(GetCharacterResponse(character: character))
-}
-
-pub fn get_character_response_to_json(input: GetCharacterResponse) -> json.Json {
-  json.object(
-    [
-      #("character", json.nullable(input.character, character_to_json)),
-    ],
-  )
-}
-
-pub fn get_character(client: squall.Client, id: String) {
-  squall.execute_query(
-    client,
-    "query GetCharacter($id: ID!) { character(id: $id) { id name status species type gender } }",
-    json.object([#("id", json.string(id))]),
-    get_character_response_decoder(),
-  )
-}

examples/02-javascript/src/graphql/get_character.gql

···
-query GetCharacter($id: ID!) {
-  character(id: $id) {
-    id
-    name
-    status
-    species
-    type
-    gender
-  }
-}

examples/02-javascript/src/graphql/get_characters.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(results: results))
-}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  decode.success(Character(id: id, name: name, status: status, species: species))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-    ],
-  )
-}
-
-pub type GetCharactersResponse {
-  GetCharactersResponse(characters: Option(Characters))
-}
-
-pub fn get_characters_response_decoder() -> decode.Decoder(GetCharactersResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  decode.success(GetCharactersResponse(characters: characters))
-}
-
-pub fn get_characters_response_to_json(input: GetCharactersResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-    ],
-  )
-}
-
-pub fn get_characters(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query GetCharacters { characters { results { id name status species } } }",
-    json.object([]),
-    get_characters_response_decoder(),
-  )
-}

examples/02-javascript/src/graphql/get_characters.gql

···
-query GetCharacters {
-  characters {
-    results {
-      id
-      name
-      status
-      species
-    }
-  }
-}

examples/02-javascript/src/graphql/multi_query.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Location(id: id))
-}
-
-pub type Episode {
-  Episode(id: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Episode(id: id))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub type MultiQueryResponse {
-  MultiQueryResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_response_decoder() -> decode.Decoder(MultiQueryResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_response_to_json(input: MultiQueryResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }",
-    json.object([]),
-    multi_query_response_decoder(),
-  )
-}

examples/02-javascript/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
-  }
-}

examples/02-javascript/src/graphql/multi_query_with_vars.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String), name: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Location(id: id, name: name))
-}
-
-pub type Episode {
-  Episode(id: Option(String), name: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Episode(id: id, name: name))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub type MultiQueryWithVarsResponse {
-  MultiQueryWithVarsResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_with_vars_response_decoder() -> decode.Decoder(MultiQueryWithVarsResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryWithVarsResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_with_vars_response_to_json(input: MultiQueryWithVarsResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query_with_vars(client: squall.Client, page: Int, name: String, location_id: String, episode_ids: List(Int)) {
-  squall.execute_query(
-    client,
-    "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 } }",
-    json.object(
-      [
-        #("page", json.int(page)),
-        #("name", json.string(name)),
-        #("locationId", json.string(location_id)),
-        #("episodeIds", json.array(from: episode_ids, of: json.int)),
-      ],
-    ),
-    multi_query_with_vars_response_decoder(),
-  )
-}

examples/02-javascript/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
-  }
-}

examples/02-javascript/src/javascript_example.gleam

···
-import gleam/io
-import gleam/javascript/promise
-import gleam/json
-import gleam/string
-import graphql/multi_query
-import squall
-
-pub fn main() {
-  io.println("Squall Multi-Field Query Example (JavaScript/Node.js)")
-  io.println("======================================================\n")
-
-  // Create a JavaScript client (uses Fetch API for HTTP requests)
-  let client =
-    squall.new_javascript_client("https://rickandmortyapi.com/graphql", [])
-
-  // On JavaScript, multi_query returns a Promise that resolves to a Result
-  // We use promise.await to wait for the result
-  multi_query.multi_query(client)
-  |> promise.await(fn(result) {
-    case result {
-      Ok(response) -> {
-        io.println("✓ Success! Received response from API\n")
-
-        // Print the Gleam data structure
-        io.println("Gleam Response Structure:")
-        io.println("-------------------------")
-        io.println(string.inspect(response))
-
-        // Convert to JSON and print
-        io.println("\nJSON Response:")
-        io.println("--------------")
-        let json_response = multi_query.multi_query_response_to_json(response)
-        io.println(json.to_string(json_response))
-
-        promise.resolve(Nil)
-      }
-      Error(err) -> {
-        io.println("✗ Error: " <> err)
-        promise.resolve(Nil)
-      }
-    }
-  })
-}

examples/03-isomorphic/README.md

···
-# Squall Isomorphic Example
-
-This example demonstrates writing **cross-platform** Gleam code that works on **both Erlang and JavaScript** targets using Squall.
-
-## What's Inside
-
-- `isomorphic_example.gleam` - Code that runs on both targets
-- `src/graphql/*.gql` - GraphQL query definitions
-- `src/graphql/*.gleam` - Generated type-safe Gleam code
-
-## The Magic: Target-Conditional Code
-
-The same codebase works on both Erlang and JavaScript using `@target()` attributes:
-
-```gleam
-import squall
-import graphql/multi_query
-
-@target(javascript)
-import gleam/javascript/promise
-
-// Shared business logic - works on both targets!
-fn handle_response(response: multi_query.MultiQueryResponse) -> Nil {
-  io.println("✓ Success!")
-  io.println(string.inspect(response))
-}
-
-fn handle_error(err: String) -> Nil {
-  io.println("✗ Error: " <> err)
-}
-
-// Erlang implementation - synchronous
-@target(erlang)
-fn run() -> Nil {
-  let client = squall.new_erlang_client("https://rickandmortyapi.com/graphql", [])
-  let result = multi_query.multi_query(client)
-
-  case result {
-    Ok(response) -> handle_response(response)
-    Error(err) -> handle_error(err)
-  }
-}
-
-// JavaScript implementation - asynchronous with Promises
-@target(javascript)
-fn run() -> promise.Promise(Nil) {
-  let client = squall.new_javascript_client("https://rickandmortyapi.com/graphql", [])
-
-  multi_query.multi_query(client)
-  |> promise.await(fn(result) {
-    case result {
-      Ok(response) -> {
-        handle_response(response)
-        promise.resolve(Nil)
-      }
-      Error(err) -> {
-        handle_error(err)
-        promise.resolve(Nil)
-      }
-    }
-  })
-}
-
-pub fn main() {
-  run()  // Works on both targets!
-}
-```
-
-## Running on Erlang
-
-```bash
-# Build and run on Erlang
-gleam run -m isomorphic_example
-```
-
-Output: `"Running on Erlang target (using gleam_httpc)"`
-
-## Running on JavaScript
-
-```bash
-# Build and run on JavaScript (Node.js)
-gleam run --target javascript -m isomorphic_example
-```
-
-Output: `"Running on JavaScript target (using Fetch API)"`
-
-## How It Works
-
-1. **Compile time**: Gleam includes only the code for the target platform
-   - On Erlang: Only the `@target(erlang)` functions are compiled
-   - On JavaScript: Only the `@target(javascript)` functions are compiled
-
-2. **Runtime**: The appropriate HTTP adapter is used automatically
-   - Erlang → `gleam_httpc` (synchronous, returns `Result`)
-   - JavaScript → Fetch API (asynchronous, returns `Promise(Result)`)
-
-3. **Shared business logic**: Response/error handlers work on both targets
-   - `handle_response()` and `handle_error()` are platform-agnostic
-   - Only the HTTP execution layer differs between platforms
-
-4. **Generated code**: Completely platform-agnostic!
-   - The same GraphQL code works everywhere
-   - No platform-specific imports in generated files
-   - Automatically adapts to sync (Erlang) or async (JavaScript) execution
-
-## Build Artifacts
-
-### Erlang Target
-```bash
-gleam build
-# Outputs to: build/dev/erlang/
-```
-
-### JavaScript Target
-```bash
-gleam build --target javascript
-# Outputs to: build/dev/javascript/
-```
-
-## Use Cases
-
-This pattern is perfect for:
-
-✅ **Full-stack Gleam apps** - Share GraphQL clients between backend (Erlang) and frontend (JavaScript)
-✅ **Multi-platform libraries** - Write once, run everywhere
-✅ **Migration scenarios** - Gradually move from one target to another
-✅ **Testing** - Test the same business logic on different runtimes
-
-## Features Demonstrated
-
-✅ **Cross-Platform Code** - Single codebase for both targets
-✅ **Conditional Compilation** - `@target()` attributes
-✅ **HTTP Adapter Pattern** - Platform-specific implementations
-✅ **Type Safety** - Fully typed across all targets
-✅ **Zero Duplication** - Generated code shared between targets

examples/03-isomorphic/gleam.toml

···
-name = "isomorphic_example"
-version = "0.1.0"
-description = "Squall isomorphic example - Works on Erlang AND JavaScript"
-
-[dependencies]
-gleam_stdlib = ">= 0.65.0 and < 0.66.0"
-gleam_json = ">= 3.0.0 and < 4.0.0"
-gleam_http = ">= 4.3.0 and < 5.0.0"
-gleam_javascript = ">= 0.3.0 and < 2.0.0"
-squall = { path = "../.." }

examples/03-isomorphic/manifest.toml

···
-# This file was generated by Gleam
-# You typically do not need to edit this file
-
-packages = [
-  { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
-  { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
-  { name = "glam", version = "2.0.3", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glam", source = "hex", outer_checksum = "237C2CE218A2A0A5D46D625F8EF5B78F964BC91018B78D692B17E1AB84295229" },
-  { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
-  { name = "gleam_fetch", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_http", "gleam_javascript", "gleam_stdlib"], otp_app = "gleam_fetch", source = "hex", outer_checksum = "2CBF9F2E1C71AEBBFB13A9D5720CD8DB4263EB02FE60C5A7A1C6E17B0151C20C" },
-  { name = "gleam_http", version = "4.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_http", source = "hex", outer_checksum = "82EA6A717C842456188C190AFB372665EA56CE13D8559BF3B1DD9E40F619EE0C" },
-  { name = "gleam_httpc", version = "5.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_http", "gleam_stdlib"], otp_app = "gleam_httpc", source = "hex", outer_checksum = "C545172618D07811494E97AAA4A0FB34DA6F6D0061FDC8041C2F8E3BE2B2E48F" },
-  { name = "gleam_javascript", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_javascript", source = "hex", outer_checksum = "EF6C77A506F026C6FB37941889477CD5E4234FCD4337FF0E9384E297CB8F97EB" },
-  { name = "gleam_json", version = "3.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "874FA3C3BB6E22DD2BB111966BD40B3759E9094E05257899A7C08F5DE77EC049" },
-  { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
-  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
-  { name = "squall", version = "0.1.0", build_tools = ["gleam"], requirements = ["argv", "filepath", "glam", "gleam_fetch", "gleam_http", "gleam_httpc", "gleam_json", "gleam_stdlib", "simplifile"], source = "local", path = "../.." },
-]
-
-[requirements]
-gleam_http = { version = ">= 4.3.0 and < 5.0.0" }
-gleam_javascript = { version = ">= 0.3.0 and < 2.0.0" }
-gleam_json = { version = ">= 3.0.0 and < 4.0.0" }
-gleam_stdlib = { version = ">= 0.65.0 and < 0.66.0" }
-squall = { path = "../.." }

examples/03-isomorphic/src/graphql/get_character.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-    type_: Option(String),
-    gender: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  use type_ <- decode.field("type", decode.optional(decode.string))
-  use gender <- decode.field("gender", decode.optional(decode.string))
-  decode.success(Character(
-    id: id,
-    name: name,
-    status: status,
-    species: species,
-    type_: type_,
-    gender: gender,
-  ))
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-      #("type", json.nullable(input.type_, json.string)),
-      #("gender", json.nullable(input.gender, json.string)),
-    ],
-  )
-}
-
-pub type GetCharacterResponse {
-  GetCharacterResponse(character: Option(Character))
-}
-
-pub fn get_character_response_decoder() -> decode.Decoder(GetCharacterResponse) {
-  use character <- decode.field("character", decode.optional(character_decoder()))
-  decode.success(GetCharacterResponse(character: character))
-}
-
-pub fn get_character_response_to_json(input: GetCharacterResponse) -> json.Json {
-  json.object(
-    [
-      #("character", json.nullable(input.character, character_to_json)),
-    ],
-  )
-}
-
-pub fn get_character(client: squall.Client, id: String) {
-  squall.execute_query(
-    client,
-    "query GetCharacter($id: ID!) { character(id: $id) { id name status species type gender } }",
-    json.object([#("id", json.string(id))]),
-    get_character_response_decoder(),
-  )
-}

examples/03-isomorphic/src/graphql/get_character.gql

···
-query GetCharacter($id: ID!) {
-  character(id: $id) {
-    id
-    name
-    status
-    species
-    type
-    gender
-  }
-}

examples/03-isomorphic/src/graphql/get_characters.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(results: results))
-}
-
-pub type Character {
-  Character(
-    id: Option(String),
-    name: Option(String),
-    status: Option(String),
-    species: Option(String),
-  )
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  use status <- decode.field("status", decode.optional(decode.string))
-  use species <- decode.field("species", decode.optional(decode.string))
-  decode.success(Character(id: id, name: name, status: status, species: species))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-      #("status", json.nullable(input.status, json.string)),
-      #("species", json.nullable(input.species, json.string)),
-    ],
-  )
-}
-
-pub type GetCharactersResponse {
-  GetCharactersResponse(characters: Option(Characters))
-}
-
-pub fn get_characters_response_decoder() -> decode.Decoder(GetCharactersResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  decode.success(GetCharactersResponse(characters: characters))
-}
-
-pub fn get_characters_response_to_json(input: GetCharactersResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-    ],
-  )
-}
-
-pub fn get_characters(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query GetCharacters { characters { results { id name status species } } }",
-    json.object([]),
-    get_characters_response_decoder(),
-  )
-}

examples/03-isomorphic/src/graphql/get_characters.gql

···
-query GetCharacters {
-  characters {
-    results {
-      id
-      name
-      status
-      species
-    }
-  }
-}

examples/03-isomorphic/src/graphql/multi_query.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Location(id: id))
-}
-
-pub type Episode {
-  Episode(id: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  decode.success(Episode(id: id))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object([#("id", json.nullable(input.id, json.string))])
-}
-
-pub type MultiQueryResponse {
-  MultiQueryResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_response_decoder() -> decode.Decoder(MultiQueryResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_response_to_json(input: MultiQueryResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query(client: squall.Client) {
-  squall.execute_query(
-    client,
-    "query MultiQuery { characters(page: 2, filter: { name: \"rick\" }) { info { count } results { name } } location(id: 1) { id } episodesByIds(ids: [1, 2]) { id } }",
-    json.object([]),
-    multi_query_response_decoder(),
-  )
-}

examples/03-isomorphic/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
-  }
-}

examples/03-isomorphic/src/graphql/multi_query_with_vars.gleam

···
-import gleam/dynamic/decode
-import gleam/json
-import squall
-import gleam/option.{type Option}
-
-pub type Characters {
-  Characters(info: Option(Info), results: Option(List(Character)))
-}
-
-pub fn characters_decoder() -> decode.Decoder(Characters) {
-  use info <- decode.field("info", decode.optional(info_decoder()))
-  use results <- decode.field("results", decode.optional(decode.list(character_decoder())))
-  decode.success(Characters(info: info, results: results))
-}
-
-pub type Info {
-  Info(count: Option(Int))
-}
-
-pub fn info_decoder() -> decode.Decoder(Info) {
-  use count <- decode.field("count", decode.optional(decode.int))
-  decode.success(Info(count: count))
-}
-
-pub type Character {
-  Character(name: Option(String))
-}
-
-pub fn character_decoder() -> decode.Decoder(Character) {
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Character(name: name))
-}
-
-pub type Location {
-  Location(id: Option(String), name: Option(String))
-}
-
-pub fn location_decoder() -> decode.Decoder(Location) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Location(id: id, name: name))
-}
-
-pub type Episode {
-  Episode(id: Option(String), name: Option(String))
-}
-
-pub fn episode_decoder() -> decode.Decoder(Episode) {
-  use id <- decode.field("id", decode.optional(decode.string))
-  use name <- decode.field("name", decode.optional(decode.string))
-  decode.success(Episode(id: id, name: name))
-}
-
-pub fn characters_to_json(input: Characters) -> json.Json {
-  json.object(
-    [
-      #("info", json.nullable(input.info, info_to_json)),
-      #("results", json.nullable(
-        input.results,
-        fn(list) { json.array(from: list, of: character_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn info_to_json(input: Info) -> json.Json {
-  json.object([#("count", json.nullable(input.count, json.int))])
-}
-
-pub fn character_to_json(input: Character) -> json.Json {
-  json.object([#("name", json.nullable(input.name, json.string))])
-}
-
-pub fn location_to_json(input: Location) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub fn episode_to_json(input: Episode) -> json.Json {
-  json.object(
-    [
-      #("id", json.nullable(input.id, json.string)),
-      #("name", json.nullable(input.name, json.string)),
-    ],
-  )
-}
-
-pub type MultiQueryWithVarsResponse {
-  MultiQueryWithVarsResponse(
-    characters: Option(Characters),
-    location: Option(Location),
-    episodes_by_ids: Option(List(Episode)),
-  )
-}
-
-pub fn multi_query_with_vars_response_decoder() -> decode.Decoder(MultiQueryWithVarsResponse) {
-  use characters <- decode.field("characters", decode.optional(characters_decoder()))
-  use location <- decode.field("location", decode.optional(location_decoder()))
-  use episodes_by_ids <- decode.field("episodesByIds", decode.optional(decode.list(episode_decoder())))
-  decode.success(MultiQueryWithVarsResponse(
-    characters: characters,
-    location: location,
-    episodes_by_ids: episodes_by_ids,
-  ))
-}
-
-pub fn multi_query_with_vars_response_to_json(input: MultiQueryWithVarsResponse) -> json.Json {
-  json.object(
-    [
-      #("characters", json.nullable(input.characters, characters_to_json)),
-      #("location", json.nullable(input.location, location_to_json)),
-      #("episodesByIds", json.nullable(
-        input.episodes_by_ids,
-        fn(list) { json.array(from: list, of: episode_to_json) },
-      )),
-    ],
-  )
-}
-
-pub fn multi_query_with_vars(client: squall.Client, page: Int, name: String, location_id: String, episode_ids: List(Int)) {
-  squall.execute_query(
-    client,
-    "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 } }",
-    json.object(
-      [
-        #("page", json.int(page)),
-        #("name", json.string(name)),
-        #("locationId", json.string(location_id)),
-        #("episodeIds", json.array(from: episode_ids, of: json.int)),
-      ],
-    ),
-    multi_query_with_vars_response_decoder(),
-  )
-}

examples/03-isomorphic/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
-  }
-}

examples/03-isomorphic/src/isomorphic_example.gleam

···
-import gleam/io
-import gleam/json
-import gleam/string
-import graphql/multi_query
-import squall
-
-@target(javascript)
-import gleam/javascript/promise
-
-// This example demonstrates how to write isomorphic code
-// that works on both Erlang and JavaScript targets
-
-pub fn main() {
-  io.println("Squall Isomorphic Example")
-  io.println("=========================\n")
-
-  // Use target-specific main implementations
-  run()
-}
-
-// Shared function to handle successful responses
-fn handle_response(response: multi_query.MultiQueryResponse) -> Nil {
-  io.println("✓ Success! Received response from API\n")
-
-  // Print the Gleam data structure
-  io.println("Gleam Response Structure:")
-  io.println("-------------------------")
-  io.println(string.inspect(response))
-
-  // Convert to JSON and print
-  io.println("\nJSON Response:")
-  io.println("--------------")
-  let json_response = multi_query.multi_query_response_to_json(response)
-  io.println(json.to_string(json_response))
-}
-
-// Shared function to handle errors
-fn handle_error(err: String) -> Nil {
-  io.println("✗ Error: " <> err)
-}
-
-// Erlang implementation - synchronous
-@target(erlang)
-fn run() -> Nil {
-  io.println("Running on Erlang target (using gleam_httpc)\n")
-
-  let client = squall.new_erlang_client("https://rickandmortyapi.com/graphql", [])
-  let result = multi_query.multi_query(client)
-
-  case result {
-    Ok(response) -> handle_response(response)
-    Error(err) -> handle_error(err)
-  }
-}
-
-// JavaScript implementation - asynchronous
-@target(javascript)
-fn run() -> promise.Promise(Nil) {
-  io.println("Running on JavaScript target (using Fetch API)\n")
-
-  let client = squall.new_javascript_client("https://rickandmortyapi.com/graphql", [])
-
-  multi_query.multi_query(client)
-  |> promise.await(fn(result) {
-    case result {
-      Ok(response) -> {
-        handle_response(response)
-        promise.resolve(Nil)
-      }
-      Error(err) -> {
-        handle_error(err)
-        promise.resolve(Nil)
-      }
-    }
-  })
-}

examples/README.md

···
-# Squall Examples
-
-Welcome to the Squall examples! These demonstrate how to use Squall's **isomorphic GraphQL client generator** with the Rick and Morty API.
-
-## 🌊 What is Squall?
-
-Squall generates **type-safe GraphQL clients** for Gleam that work on **any target** - Erlang, JavaScript (Browser), and JavaScript (Node.js). Write `.gql` files, and Squall generates fully-typed Gleam code with proper types, decoders, and serializers.
-
-## Examples Overview
-
-### [01-erlang](./01-erlang/) - Erlang/OTP Target
-
-Demonstrates Squall on the Erlang/OTP runtime using `gleam_httpc`.
-
-```bash
-cd 01-erlang
-gleam run -m erlang_example
-```
-
-**Perfect for:** Backend services, servers, distributed systems
-
-### [02-javascript](./02-javascript/) - JavaScript Target
-
-Demonstrates Squall on JavaScript (Node.js/Browser) using the Fetch API.
-
-```bash
-cd 02-javascript
-gleam run -m javascript_example
-```
-
-**Perfect for:** Frontend apps, serverless functions, Deno
-
-### [03-isomorphic](./03-isomorphic/) - Cross-Platform
-
-Demonstrates writing code that works on **both** Erlang and JavaScript!
-
-```bash
-cd 03-isomorphic
-
-# Run on Erlang
-gleam run -m isomorphic_example
-
-# Run on JavaScript
-gleam run --target javascript -m isomorphic_example
-```
-
-**Perfect for:** Full-stack apps, shared libraries, universal code
-
-## Quick Start
-
-### 1. Generate GraphQL Code
-
-From the Squall root directory:
-
-```bash
-gleam run -m squall generate https://rickandmortyapi.com/graphql
-```
-
-This discovers all `.gql` files in the examples and generates type-safe Gleam code.
-
-### 2. Choose Your Target
-
-Pick the example that matches your use case:
-
-| Target | Example | Use Case |
-|--------|---------|----------|
-| **Erlang** | `01-erlang` | Backend, servers |
-| **JavaScript** | `02-javascript` | Frontend, Node.js |
-| **Both** | `03-isomorphic` | Full-stack apps |
-
-### 3. Run It!
-
-```bash
-cd <example-folder>
-gleam run
-```
-
-## The Key Difference
-
-The **only difference** between Erlang and JavaScript code is the client creation:
-
-```gleam
-// Erlang
-let client = squall.new_erlang_client(endpoint, headers)
-
-// JavaScript
-let client = squall.new_javascript_client(endpoint, headers)
-
-// Cross-platform (uses @target conditionals)
-@target(erlang)
-fn create_client() -> squall.Client {
-  squall.new_erlang_client(endpoint, headers)
-}
-
-@target(javascript)
-fn create_client() -> squall.Client {
-  squall.new_javascript_client(endpoint, headers)
-}
-```
-
-**Everything else is identical!** The same generated GraphQL code works everywhere.
-
-## API Endpoint
-
-All examples use the public Rick and Morty GraphQL API:
-
-```
-https://rickandmortyapi.com/graphql
-```
-
-No API key required!
-
-## GraphQL Queries
-
-Each example includes the same `.gql` files:
-
-- **`get_character.gql`** - Fetch a single character by ID
-- **`get_characters.gql`** - Fetch a list of characters
-- **`multi_query.gql`** - Multiple fields in one query
-- **`multi_query_with_vars.gql`** - Query with GraphQL variables
-
-## Features Demonstrated
-
-✅ **Type Safety** - All queries fully typed from GraphQL schema
-✅ **Isomorphic** - Same code works on Erlang and JavaScript
-✅ **Variables** - Type-safe GraphQL variable handling
-✅ **Nested Objects** - Automatic decoder generation for complex types
-✅ **Optional Fields** - Proper `Option` type handling
-✅ **JSON Serialization** - Convert responses to/from JSON
-✅ **HTTP Adapters** - Platform-specific HTTP implementations
-
-## Project Structure
-
-```
-examples/
-├── README.md                    # This file
-├── 01-erlang/                   # Erlang example
-│   ├── gleam.toml
-│   ├── README.md
-│   └── src/
-│       ├── erlang_example.gleam
-│       ├── example_with_vars.gleam
-│       └── graphql/
-│           ├── *.gql           # GraphQL queries
-│           └── *.gleam         # Generated code
-├── 02-javascript/               # JavaScript example
-│   ├── gleam.toml
-│   ├── README.md
-│   └── src/
-│       ├── javascript_example.gleam
-│       └── graphql/
-│           ├── *.gql
-│           └── *.gleam
-└── 03-isomorphic/              # Cross-platform example
-    ├── gleam.toml
-    ├── README.md
-    └── src/
-        ├── isomorphic_example.gleam
-        └── graphql/
-            ├── *.gql
-            └── *.gleam
-```
-
-## Next Steps
-
-1. **Explore the examples** - Start with the one matching your target
-2. **Read the individual READMEs** - Each has detailed instructions
-3. **Modify the queries** - Edit `.gql` files and regenerate
-4. **Try your own API** - Point Squall at your GraphQL endpoint!
-
-## Learn More
-
-- [Squall Documentation](../../CLAUDE.md)
-- [Rick and Morty GraphQL API](https://rickandmortyapi.com/documentation/#graphql)
-- [Gleam Language](https://gleam.run)
-
-Happy querying! 🌊

src/squall.gleam

···
 import argv
 import gleam/dynamic/decode
 import gleam/http
-import gleam/http/request
+import gleam/http/request.{type Request}
 import gleam/httpc
 import gleam/io
 import gleam/json
 import gleam/list
 import gleam/result
 import gleam/string
-import squall/adapter.{type HttpAdapter}
 
 @target(erlang)
 import simplifile
···
 @target(erlang)
 import squall/internal/schema
 
-@target(erlang)
-import squall/adapter/erlang
-
-@target(javascript)
-import squall/adapter/javascript
-
-@target(javascript)
-import gleam/javascript/promise.{type Promise}
-
-/// A GraphQL client with endpoint, headers, and HTTP adapter configuration
+/// A GraphQL client with endpoint and headers configuration.
+/// This client follows the sans-io pattern: it builds HTTP requests but doesn't send them.
+/// You must use your own HTTP client to send the requests.
 pub type Client {
-  Client(
-    endpoint: String,
-    headers: List(#(String, String)),
-    send_request: HttpAdapter,
-  )
+  Client(endpoint: String, headers: List(#(String, String)))
 }
 
-/// Create a new GraphQL client with custom headers and HTTP adapter.
-/// For most cases, use target-specific constructors like `new_erlang_client` or `new_javascript_client`.
-pub fn new_client(
-  endpoint: String,
-  headers: List(#(String, String)),
-  send_request: HttpAdapter,
-) -> Client {
-  Client(endpoint: endpoint, headers: headers, send_request: send_request)
-}
-
-/// Create a new GraphQL client with bearer token authentication and HTTP adapter.
-pub fn new_client_with_auth(
-  endpoint: String,
-  token: String,
-  send_request: HttpAdapter,
-) -> Client {
-  Client(
-    endpoint: endpoint,
-    headers: [#("Authorization", "Bearer " <> token)],
-    send_request: send_request,
-  )
-}
-
-@target(erlang)
-/// Create a new Erlang GraphQL client with custom headers.
-/// This uses the Erlang HTTP adapter (gleam_httpc).
-pub fn new_erlang_client(
-  endpoint: String,
-  headers: List(#(String, String)),
-) -> Client {
-  Client(endpoint: endpoint, headers: headers, send_request: erlang.adapter())
+/// Create a new GraphQL client with custom headers.
+///
+/// ## Example
+///
+/// ```gleam
+/// let client = squall.new("https://api.example.com/graphql", [])
+/// ```
+pub fn new(endpoint: String, headers: List(#(String, String))) -> Client {
+  Client(endpoint: endpoint, headers: headers)
 }
 
-@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,
-    headers: [#("Authorization", "Bearer " <> token)],
-    send_request: erlang.adapter(),
-  )
+/// Create a new GraphQL client with bearer token authentication.
+///
+/// ## Example
+///
+/// ```gleam
+/// let client = squall.new_with_auth("https://api.example.com/graphql", "my-token")
+/// ```
+pub fn new_with_auth(endpoint: String, token: String) -> Client {
+  Client(endpoint: endpoint, headers: [#("Authorization", "Bearer " <> token)])
 }
 
-@target(javascript)
-/// Create a new JavaScript GraphQL client with custom headers.
-/// This uses the JavaScript HTTP adapter (Fetch API).
-pub fn new_javascript_client(
-  endpoint: String,
-  headers: List(#(String, String)),
-) -> Client {
-  Client(
-    endpoint: endpoint,
-    headers: headers,
-    send_request: javascript.adapter(),
-  )
-}
-
-@target(javascript)
-/// Create a new JavaScript GraphQL client with bearer token authentication.
-pub fn new_javascript_client_with_auth(
-  endpoint: String,
-  token: String,
-) -> Client {
-  Client(
-    endpoint: endpoint,
-    headers: [#("Authorization", "Bearer " <> token)],
-    send_request: javascript.adapter(),
-  )
-}
-
-@target(javascript)
-/// Execute a GraphQL query on JavaScript targets.
-/// Returns a Promise that resolves to a Result containing the decoded response.
-pub fn execute_query(
+/// Prepare an HTTP request for a GraphQL query.
+/// This function builds the request but does not send it.
+/// You must send the request using your own HTTP client.
+///
+/// ## Example
+///
+/// ```gleam
+/// let client = squall.new("https://api.example.com/graphql", [])
+/// let request = squall.prepare_request(
+///   client,
+///   "query { users { id name } }",
+///   json.object([]),
+/// )
+///
+/// // Send with your HTTP client (Erlang example)
+/// let assert Ok(response) = httpc.send(request)
+///
+/// // Parse the response
+/// let assert Ok(data) = squall.parse_response(response.body, your_decoder)
+/// ```
+pub fn prepare_request(
   client: Client,
   query: String,
   variables: json.Json,
-  decoder: decode.Decoder(a),
-) -> Promise(Result(a, String)) {
-  let body =
-    json.object([#("query", json.string(query)), #("variables", variables)])
-
-  // Build the request
-  let req_result =
-    request.to(client.endpoint)
-    |> result.map_error(fn(_) { "Invalid endpoint URL" })
-    |> result.map(fn(req) {
-      req
-      |> request.set_method(http.Post)
-      |> request.set_body(json.to_string(body))
-      |> request.set_header("content-type", "application/json")
-    })
-    |> result.map(fn(req) {
-      list.fold(client.headers, req, fn(r, header) {
-        request.set_header(r, header.0, header.1)
-      })
-    })
-
-  // Convert Result to Promise
-  case req_result {
-    Error(e) -> promise.resolve(Error(e))
-    Ok(req) -> {
-      // Send request and process response
-      client.send_request(req)
-      |> promise.map(result.map_error(_, fn(_) { "HTTP request failed" }))
-      |> promise.try_await(fn(resp) {
-        // Parse JSON
-        let json_result =
-          json.parse(from: resp.body, using: decode.dynamic)
-          |> result.map_error(fn(_) { "Failed to decode JSON response" })
-
-        case json_result {
-          Error(e) -> promise.resolve(Error(e))
-          Ok(json_value) -> {
-            // Decode response
-            let data_decoder = {
-              use data <- decode.field("data", decoder)
-              decode.success(data)
-            }
-
-            decode.run(json_value, data_decoder)
-            |> result.map_error(fn(_) { "Failed to decode response data" })
-            |> promise.resolve
-          }
-        }
-      })
-    }
-  }
-}
-
-@target(erlang)
-/// Execute a GraphQL query on Erlang targets.
-/// Returns a Result containing the decoded response.
-pub fn execute_query(
-  client: Client,
-  query: String,
-  variables: json.Json,
-  decoder: decode.Decoder(a),
-) -> Result(a, String) {
+) -> Result(Request(String), String) {
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
 
···
       request.set_header(r, header.0, header.1)
     })
 
-  use resp <- result.try(
-    client.send_request(req)
-    |> result.map_error(fn(_) { "HTTP request failed" }),
-  )
+  Ok(req)
+}
 
+/// Parse a GraphQL response body using the provided decoder.
+/// This function decodes the JSON response and extracts the data field.
+///
+/// ## Example
+///
+/// ```gleam
+/// let decoder = decode.field("users", decode.list(user_decoder))
+///
+/// case squall.parse_response(response_body, decoder) {
+///   Ok(users) -> io.println("Got users!")
+///   Error(err) -> io.println("Parse error: " <> err)
+/// }
+/// ```
+pub fn parse_response(
+  body: String,
+  decoder: decode.Decoder(a),
+) -> Result(a, String) {
   use json_value <- result.try(
-    json.parse(from: resp.body, using: decode.dynamic)
+    json.parse(from: body, using: decode.dynamic)
     |> result.map_error(fn(_) { "Failed to decode JSON response" }),
   )
 

src/squall/adapter.gleam

···
-import gleam/http/request.{type Request}
-import gleam/http/response.{type Response}
-
-@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.
-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.
-pub type HttpAdapter =
-  fn(Request(String)) -> Promise(Result(Response(String), String))

src/squall/adapter/erlang.gleam

···
-@target(erlang)
-import gleam/http/request.{type Request}
-@target(erlang)
-import gleam/http/response.{type Response}
-@target(erlang)
-import gleam/httpc
-@target(erlang)
-import gleam/result
-@target(erlang)
-import squall/adapter.{type HttpAdapter}
-
-@target(erlang)
-/// Erlang-specific HTTP adapter using gleam_httpc.
-/// This adapter works on the Erlang/OTP target.
-pub fn adapter() -> HttpAdapter {
-  fn(req: Request(String)) -> Result(Response(String), String) {
-    httpc.send(req)
-    |> result.map_error(fn(_) { "HTTP request failed" })
-  }
-}

src/squall/adapter/javascript.gleam

···
-@target(javascript)
-import gleam/fetch
-@target(javascript)
-import gleam/http/request
-@target(javascript)
-import gleam/http/response
-@target(javascript)
-import gleam/javascript/promise.{type Promise}
-@target(javascript)
-import gleam/result
-@target(javascript)
-import squall/adapter
-
-@target(javascript)
-/// JavaScript-specific HTTP adapter using the Fetch API via gleam_fetch.
-/// 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),
-  ) {
-    fetch.send(req)
-    |> promise.try_await(fetch.read_text_body)
-    |> promise.map(result.map_error(_, fn(_) { "HTTP request failed" }))
-  }
-}

src/squall/internal/codegen.gleam

···
   // Minimal imports - just what we need for decoders and the squall client
   let core_imports = [
     "import gleam/dynamic/decode",
+    "import gleam/http/request.{type Request}",
     "import gleam/json",
     "import squall",
   ]
···
   }
 }
 
-// Generate function
+// Generate two functions: one to prepare the request, one to parse the response
 fn generate_function(
   operation_name: String,
   response_type_name: String,
+  variables: List(graphql_ast.Variable),
+  query_string: String,
+  schema_types: dict.Dict(String, schema.Type),
+) -> Document {
+  // Generate the prepare request function
+  let prepare_function = generate_prepare_function(
+    operation_name,
+    variables,
+    query_string,
+    schema_types,
+  )
+
+  // Generate the parse response function
+  let parse_function = generate_parse_function(operation_name, response_type_name)
+
+  // Combine both functions with a line break
+  doc.concat([prepare_function, doc.lines(2), parse_function])
+}
+
+// Generate the function that prepares the HTTP request
+fn generate_prepare_function(
+  operation_name: String,
   variables: List(graphql_ast.Variable),
   query_string: String,
   schema_types: dict.Dict(String, schema.Type),
···
     }
   }
 
-  // Build simplified function body that just calls squall.execute_query
+  // Build function body that calls squall.prepare_request
   let body_doc =
-    call_doc("squall.execute_query", [
+    call_doc("squall.prepare_request", [
       doc.from_string("client"),
       string_doc(query_string),
       variables_code,
-      doc.from_string(snake_case(response_type_name) <> "_decoder()"),
     ])
 
-  // Build function signature
-  // The return type is handled by squall.execute_query (Promise on JS, Result on Erlang)
+  // Build function signature with explicit return type
   doc.concat([
     doc.from_string("pub fn " <> function_name),
     comma_list("(", param_docs, ")"),
-    doc.from_string(" "),
+    doc.from_string(" -> Result(Request(String), String) "),
+    block([body_doc]),
+  ])
+}
+
+// Generate the function that parses the response body
+fn generate_parse_function(
+  operation_name: String,
+  response_type_name: String,
+) -> Document {
+  let function_name = "parse_" <> operation_name <> "_response"
+  let decoder_name = snake_case(response_type_name) <> "_decoder"
+
+  let body_doc =
+    call_doc("squall.parse_response", [
+      doc.from_string("body"),
+      doc.from_string(decoder_name <> "()"),
+    ])
+
+  doc.concat([
+    doc.from_string("pub fn " <> function_name),
+    doc.from_string("(body: String) -> Result("),
+    doc.from_string(response_type_name),
+    doc.from_string(", String) "),
     block([body_doc]),
   ])
 }