Struct JetServer 

pub struct JetServer { /* private fields */ }

AT-Jet HTTP Server

A high-performance HTTP server optimized for Protobuf APIs.

Example

use at_jet::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let server = JetServer::new()
        .route("/api/health", get(health_check))
        .with_cors()
        .with_compression()
        .with_tracing();

    server.serve("0.0.0.0:8080").await?;
    Ok(())
}

async fn health_check() -> &'static str {
    "OK"
}

Implementations

impl JetServer

pub fn new() -> Self

Create a new JetServer instance

pub fn route(self, path: &str, method_router: MethodRouter) -> Self

Add a route to the server

Example

use at_jet::prelude::*;

let server = JetServer::new()
    .route("/api/users", get(list_users).post(create_user))
    .route("/api/users/:id", get(get_user).delete(delete_user));

pub fn merge(self, router: Router) -> Self

Merge another router into this server

pub fn nest(self, path: &str, router: Router) -> Self

Nest a router under a path prefix

Example

use at_jet::prelude::*;

let api_routes = Router::new()
    .route("/users", get(list_users))
    .route("/posts", get(list_posts));

let server = JetServer::new()
    .nest("/api/v1", api_routes);

pub fn with_cors(self) -> Self

Enable CORS with permissive defaults (suitable for development)

This allows any origin, method, and header. For production, use with_cors_config() for fine-grained control.

Example

let server = JetServer::new()
    .route("/api/users", get(list_users))
    .with_cors();  // Allow all origins (development only)

pub fn with_cors_config(self, cors: CorsLayer) -> Self

Enable CORS with custom configuration (recommended for production)

Example

use tower_http::cors::{CorsLayer, AllowOrigin};
use http::{HeaderValue, Method};

let cors = CorsLayer::new()
    .allow_origin([
        "https://app.example.com".parse::<HeaderValue>().unwrap(),
        "https://admin.example.com".parse::<HeaderValue>().unwrap(),
    ])
    .allow_methods([Method::GET, Method::POST, Method::PUT, Method::DELETE])
    .allow_headers([http::header::CONTENT_TYPE, http::header::AUTHORIZATION])
    .allow_credentials(true)
    .max_age(Duration::from_secs(3600));

let server = JetServer::new()
    .route("/api/users", get(list_users))
    .with_cors_config(cors);

pub fn with_compression(self) -> Self

Enable response compression (gzip)

pub fn with_tracing(self) -> Self

Enable request/response tracing

This adds detailed logging for HTTP requests including:

• Request method, URI, and version
• Response status code
• Request duration

Requires a tracing subscriber to be initialized.

Example

use tracing_subscriber::EnvFilter;

// Initialize tracing subscriber
tracing_subscriber::fmt()
    .with_env_filter(EnvFilter::from_default_env())
    .init();

let server = JetServer::new()
    .route("/api/users", get(list_users))
    .with_tracing();

pub fn layer<L>(self, layer: L) -> Self

where L: Layer<Route> + Clone + Send + 'static, L::Service: Service<Request, Response = Response, Error = Infallible> + Clone + Send + 'static, <L::Service as Service<Request>>::Future: Send + 'static,

Add a custom middleware layer to the server

This method allows you to add any tower-compatible middleware layer.

Example - Request Timeout

use std::time::Duration;
use tower_http::timeout::TimeoutLayer;

let server = JetServer::new()
    .route("/api/users", get(list_users))
    .layer(TimeoutLayer::new(Duration::from_secs(30)));

Example - Custom Authentication Middleware

use axum::{middleware, http::Request, response::Response};

async fn auth_middleware<B>(
    request: Request<B>,
    next: axum::middleware::Next<B>,
) -> Response {
    // Check authentication here
    next.run(request).await
}

let server = JetServer::new()
    .route("/api/users", get(list_users))
    .layer(middleware::from_fn(auth_middleware));

pub fn into_router(self) -> Router

Get the router for advanced customization

pub async fn serve(self, addr: &str) -> Result<()>

Start the server

Arguments

• addr - Address to bind to (e.g., “0.0.0.0:8080”)

Example

use at_jet::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let server = JetServer::new()
        .route("/health", get(|| async { "OK" }));

    server.serve("0.0.0.0:8080").await?;
    Ok(())
}

Trait Implementations

impl Default for JetServer

fn default() -> Self

Returns the “default value” for a type.