solidb 1.0.1

A lightweight, high-performance structured database server written in Rust.
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
128
129
130
131
132

use axum::{
    http::{header, HeaderMap, StatusCode},
    response::{IntoResponse, Json, Response},
};
use serde::Serialize;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ApiFormat {
    Json,
    MsgPack,
}

impl ApiFormat {
    pub fn from_headers(headers: &HeaderMap) -> Self {
        if let Some(accept) = headers.get(header::ACCEPT) {
            if let Ok(s) = accept.to_str() {
                // Check if client explicitly prefers msgpack
                // We could do full content negotiation parsing q-values but simple contains check is usually enough
                if s.contains("application/msgpack") || s.contains("application/x-msgpack") {
                    return ApiFormat::MsgPack;
                }
            }
        }
        ApiFormat::Json
    }
}

pub struct ApiResponse<T: Serialize> {
    pub data: T,
    pub format: ApiFormat,
}

impl<T: Serialize> ApiResponse<T> {
    pub fn new(data: T, headers: &HeaderMap) -> Self {
        Self {
            data,
            format: ApiFormat::from_headers(headers),
        }
    }
}

impl<T: Serialize> IntoResponse for ApiResponse<T> {
    fn into_response(self) -> Response {
        match self.format {
            ApiFormat::Json => Json(self.data).into_response(),
            ApiFormat::MsgPack => {
                // Use to_vec_named to serialize structs as maps (key-value) instead of arrays
                // This makes it compatible with JSON structure and most clients
                match rmp_serde::to_vec_named(&self.data) {
                    Ok(bytes) => {
                        ([(header::CONTENT_TYPE, "application/msgpack")], bytes).into_response()
                    }
                    Err(e) => {
                        // Fallback to JSON error if serialization fails
                        let err_body = serde_json::json!({
                            "error": format!("Serialization error: {}", e)
                        });
                        (StatusCode::INTERNAL_SERVER_ERROR, Json(err_body)).into_response()
                    }
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_api_format_default_json() {
        let headers = HeaderMap::new();
        assert_eq!(ApiFormat::from_headers(&headers), ApiFormat::Json);
    }

    #[test]
    fn test_api_format_accept_json() {
        let mut headers = HeaderMap::new();
        headers.insert(header::ACCEPT, "application/json".parse().unwrap());
        assert_eq!(ApiFormat::from_headers(&headers), ApiFormat::Json);
    }

    #[test]
    fn test_api_format_accept_msgpack() {
        let mut headers = HeaderMap::new();
        headers.insert(header::ACCEPT, "application/msgpack".parse().unwrap());
        assert_eq!(ApiFormat::from_headers(&headers), ApiFormat::MsgPack);
    }

    #[test]
    fn test_api_format_accept_x_msgpack() {
        let mut headers = HeaderMap::new();
        headers.insert(header::ACCEPT, "application/x-msgpack".parse().unwrap());
        assert_eq!(ApiFormat::from_headers(&headers), ApiFormat::MsgPack);
    }

    #[test]
    fn test_api_format_equality() {
        assert_eq!(ApiFormat::Json, ApiFormat::Json);
        assert_eq!(ApiFormat::MsgPack, ApiFormat::MsgPack);
        assert_ne!(ApiFormat::Json, ApiFormat::MsgPack);
    }

    #[test]
    fn test_api_format_clone() {
        let format = ApiFormat::Json;
        let cloned = format;
        assert_eq!(format, cloned);
    }

    #[test]
    fn test_api_format_debug() {
        let format = ApiFormat::Json;
        let debug = format!("{:?}", format);
        assert!(debug.contains("Json"));
    }

    #[test]
    fn test_api_response_new_json() {
        let headers = HeaderMap::new();
        let response = ApiResponse::new(serde_json::json!({"key": "value"}), &headers);
        assert_eq!(response.format, ApiFormat::Json);
    }

    #[test]
    fn test_api_response_new_msgpack() {
        let mut headers = HeaderMap::new();
        headers.insert(header::ACCEPT, "application/msgpack".parse().unwrap());
        let response = ApiResponse::new(serde_json::json!({"key": "value"}), &headers);
        assert_eq!(response.format, ApiFormat::MsgPack);
    }
}