tideway 0.7.21

A batteries-included Rust web framework built on Axum for building SaaS applications quickly
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use axum::http::Request;
use axum::{Json, Router, routing::get};
use criterion::{Criterion, black_box, criterion_group, criterion_main};
use serde_json::json;
use tower::ServiceExt;

// Raw Axum hello world
fn raw_axum_hello() -> Router {
    Router::new().route("/hello", get(|| async { "Hello, World!" }))
}

// Tideway hello world with default middleware
fn tideway_hello() -> Router {
    // Simplified for benchmark - in real usage would use App::new()
    Router::new().route("/hello", get(|| async { "Hello, World!" }))
}

// Raw Axum JSON response
fn raw_axum_json() -> Router {
    Router::new().route(
        "/json",
        get(|| async { Json(json!({"message": "Hello", "status": "ok"})) }),
    )
}

// Tideway JSON response with ApiResponse
fn tideway_json() -> Router {
    Router::new().route(
        "/json",
        get(|| async {
            use tideway::ApiResponse;
            Json(ApiResponse::success(json!({"message": "Hello"})))
        }),
    )
}

async fn make_request(router: &Router, path: &str) {
    let req = Request::builder()
        .uri(path)
        .body(axum::body::Body::empty())
        .unwrap();

    let _response = router.clone().oneshot(req).await.unwrap();
}

fn benchmark_hello_world(c: &mut Criterion) {
    let mut group = c.benchmark_group("hello_world");

    let raw_router = raw_axum_hello();
    let tideway_router = tideway_hello();

    let rt = tokio::runtime::Runtime::new().unwrap();

    group.bench_function("raw_axum", |b| {
        b.iter(|| {
            rt.block_on(make_request(black_box(&raw_router), "/hello"));
        });
    });

    group.bench_function("tideway", |b| {
        b.iter(|| {
            rt.block_on(make_request(black_box(&tideway_router), "/hello"));
        });
    });

    group.finish();
}

fn benchmark_json_response(c: &mut Criterion) {
    let mut group = c.benchmark_group("json_response");

    let raw_router = raw_axum_json();
    let tideway_router = tideway_json();

    let rt = tokio::runtime::Runtime::new().unwrap();

    group.bench_function("raw_axum", |b| {
        b.iter(|| {
            rt.block_on(make_request(black_box(&raw_router), "/json"));
        });
    });

    group.bench_function("tideway", |b| {
        b.iter(|| {
            rt.block_on(make_request(black_box(&tideway_router), "/json"));
        });
    });

    group.finish();
}

criterion_group!(benches, benchmark_hello_world, benchmark_json_response);
criterion_main!(benches);