openkind-api 0.2.0

Phase 1: HTTP (axum) and gRPC (tonic) protocol layer for openkind.
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Unit tests for request ID middleware and header sanitization.

use axum::{
    body::Body,
    http::{Request, StatusCode},
    middleware,
    routing::get,
    Router,
};
use tower::ServiceExt;

use crate::middleware::{
    is_safe_request_id, request_id_layer, MAX_REQUEST_ID_LEN, REQUEST_ID_HEADER,
};

async fn echo() -> &'static str {
    "ok"
}

fn app() -> Router {
    Router::new()
        .route("/health", get(echo))
        .layer(middleware::from_fn(request_id_layer))
}

#[tokio::test]
async fn response_carries_request_id_header() {
    let resp = app()
        .oneshot(
            Request::builder()
                .uri("/health")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let id = resp
        .headers()
        .get(&REQUEST_ID_HEADER)
        .expect("response must carry x-typesafe-request-id");
    let s = id.to_str().unwrap();
    assert_eq!(s.len(), 36, "expected uuid length, got {s:?}");
}

#[tokio::test]
async fn inbound_request_id_is_honored() {
    let resp = app()
        .oneshot(
            Request::builder()
                .uri("/health")
                .header(&REQUEST_ID_HEADER, "test-id-123")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(
        resp.headers().get(&REQUEST_ID_HEADER).unwrap(),
        "test-id-123"
    );
}

#[test]
fn is_safe_request_id_accepts_safe_shapes() {
    assert!(is_safe_request_id("a"));
    assert!(is_safe_request_id("550e8400-e29b-41d4-a716-446655440000"));
    assert!(is_safe_request_id("allowed-chars_A.b0"));
    assert!(is_safe_request_id(&"a".repeat(MAX_REQUEST_ID_LEN)));
}

#[test]
fn is_safe_request_id_rejects_unsafe_shapes() {
    assert!(!is_safe_request_id(""));
    assert!(!is_safe_request_id(&"a".repeat(MAX_REQUEST_ID_LEN + 1)));
    assert!(!is_safe_request_id("has space"));
    assert!(!is_safe_request_id("semi;colon"));
    assert!(!is_safe_request_id("new\nline"));
    assert!(!is_safe_request_id("tab\tchar"));
    assert!(!is_safe_request_id("sl/ash"));
    assert!(!is_safe_request_id("quer?y"));
    assert!(!is_safe_request_id("ang<l>e"));
    assert!(!is_safe_request_id("émoji"));
}

#[tokio::test]
async fn inbound_unsafe_request_id_is_sanitized() {
    // Injection attempt with unsafe chars (spaces, brackets, semicolons)
    let resp = app()
        .oneshot(
            Request::builder()
                .uri("/health")
                .header(&REQUEST_ID_HEADER, "<script>malicious;id</script>")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    let id = resp
        .headers()
        .get(&REQUEST_ID_HEADER)
        .unwrap()
        .to_str()
        .unwrap();
    assert_ne!(id, "<script>malicious;id</script>");
    assert_eq!(id.len(), 36, "should fall back to fresh UUIDv4");

    // Oversized ID attempt (> 128 chars)
    let long_id = "a".repeat(200);
    let resp2 = app()
        .oneshot(
            Request::builder()
                .uri("/health")
                .header(&REQUEST_ID_HEADER, long_id)
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    let id2 = resp2
        .headers()
        .get(&REQUEST_ID_HEADER)
        .unwrap()
        .to_str()
        .unwrap();
    assert_eq!(id2.len(), 36, "should fall back to fresh UUIDv4");
}