waygate

waygate is a modern HTTP client for Rust. It focuses on predictable behaviour, a clean async API, and a design that can grow with services, CLIs, and libraries.

This repository currently contains an early 0.1.0 release of the library.

Status

The 0.1.0 release is intentionally small and focused:

Core client and HTTP types are defined.
A generic client type can be backed by different HTTP implementations.
A mock backend is available for fast, deterministic tests.
A hyper-based backend is available for real HTTP/1.1 and HTTP/2 traffic on Tokio.

Streaming bodies and more advanced configuration options are planned but not yet implemented in this release.

Features

Async client built on top of Tokio and hyper.
Backend abstraction so the same client API can be used with different HTTP stacks.
Mock client for unit and integration tests that do not need real network calls.
Hyper-backed client for real HTTP requests.
Simple configuration structure for basic timeouts and redirect limits.
Unified error type with clear variants for configuration and transport problems.

Installation

Add the crate to your Cargo.toml:

[dependencies]

waygate = "0.1.0"

Then import it in your code:

use waygate::HyperClient;

Quickstart

The example below performs a simple GET request using the hyper-backed client.

use http::Uri;
use waygate::HyperClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = HyperClient::new();

    let uri: Uri = "https://example.com".parse()?;
    let response = client.get(uri).await?;

    println!("Status: {}", response.status);
    println!("Body: {}", String::from_utf8_lossy(&response.body));

    Ok(())
}

For tests or local development, you can use the mock client:

use http::{Method, Uri};
use waygate::{MockClient, request::Request};

#[tokio::test]
async fn example_with_mock_client() {
    let client = MockClient::new();
    let uri: Uri = "http://example.test".parse().unwrap();
    let request = Request::new(Method::GET, uri);

    let response = client.send(request).await.unwrap();
    assert_eq!(response.status.as_u16(), 501);
}

Configuration

The client exposes a simple configuration structure that can be adjusted as needed:

use std::time::Duration;
use http::Uri;
use waygate::HyperClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = HyperClient::new();
    client.config_mut().request_timeout = Some(Duration::from_secs(5));

    let uri: Uri = "https://example.com".parse()?;
    let _response = client.get(uri).await?;

    Ok(())
}

As the library evolves, this configuration will grow to cover more advanced behaviour such as retry policies and redirect handling.

Roadmap

Planned areas of improvement include:

Streaming request and response bodies.
Richer configuration (retries, redirects, connection pooling controls).
Additional backend implementations.
More examples and stronger documentation.

For a more detailed view of the direction and milestones, see plan.md in the repository root.

License

This project is distributed under the terms of the license found in the LICENSE file.

waygate 0.1.0