resuma 1.0.0

Resuma — resumable SSR Rust web framework: zero hydration, islands, server actions, Flow (Axum).
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
133
134
135
136
137
138
139

//! Typed extractors for Resuma Flow loaders, submits, and server actions.
//!
//! ```ignore
//! #[load]
//! async fn user(id: Path<u64>, q: Query<SearchParams>) -> UserData { ... }
//!
//! #[submit]
//! async fn save(form: CreateUser, q: Query<RedirectTo>) -> Result<(), SubmitError> { ... }
//! ```

use serde::de::DeserializeOwned;
use serde_json::{Map, Value};

use crate::core::{FlowRequest, ResumaError, Result};

/// Extract route params (`:id`, `:slug`, …) into a typed value.
///
/// For a single param route, `Path<u64>` reads the lone value. For multiple
/// params, use a struct with `#[derive(Deserialize)]` and field names matching
/// the route pattern.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Path<T>(pub T);

/// Extract query-string parameters into a typed value.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Query<T>(pub T);

/// Deserialize route params from a request.
pub trait FromFlowRequest: Sized {
    fn from_request(req: &FlowRequest) -> Result<Self>;
}

impl<T> FromFlowRequest for Path<T>
where
    T: DeserializeOwned,
{
    fn from_request(req: &FlowRequest) -> Result<Self> {
        if req.params.is_empty() {
            return Err(ResumaError::Validation(
                "Path extractor: no route params on this request".into(),
            ));
        }

        if req.params.len() == 1 {
            let raw = req.params.values().next().expect("checked len");
            if let Ok(parsed) = parse_scalar::<T>(raw) {
                return Ok(Path(parsed));
            }
        }

        let map = string_map_to_json(&req.params);
        serde_json::from_value(Value::Object(map))
            .map(Path)
            .map_err(|e| {
                ResumaError::Validation(format!(
                    "Path extractor: could not decode params into `{}`: {e}",
                    std::any::type_name::<T>()
                ))
            })
    }
}

impl<T> FromFlowRequest for Query<T>
where
    T: DeserializeOwned,
{
    fn from_request(req: &FlowRequest) -> Result<Self> {
        if req.query.is_empty() {
            return Err(ResumaError::Validation(
                "Query extractor: no query params on this request".into(),
            ));
        }

        if req.query.len() == 1 {
            let raw = req.query.values().next().expect("checked len");
            if let Ok(parsed) = parse_scalar::<T>(raw) {
                return Ok(Query(parsed));
            }
        }

        let map = string_map_to_json(&req.query);
        serde_json::from_value(Value::Object(map))
            .map(Query)
            .map_err(|e| {
                ResumaError::Validation(format!(
                    "Query extractor: could not decode query into `{}`: {e}",
                    std::any::type_name::<T>()
                ))
            })
    }
}

impl FromFlowRequest for FlowRequest {
    fn from_request(req: &FlowRequest) -> Result<Self> {
        Ok(req.clone())
    }
}

fn string_map_to_json(map: &std::collections::BTreeMap<String, String>) -> Map<String, Value> {
    map.iter()
        .map(|(k, v)| (k.clone(), Value::String(v.clone())))
        .collect()
}

fn parse_scalar<T: DeserializeOwned>(raw: &str) -> Result<T> {
    if let Ok(v) = serde_json::from_str::<T>(raw) {
        return Ok(v);
    }
    serde_json::from_value(Value::String(raw.to_string())).map_err(|e| {
        ResumaError::Validation(format!(
            "Could not parse `{raw}` into `{}`: {e}",
            std::any::type_name::<T>()
        ))
    })
}

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

    #[test]
    fn path_single_param_u64() {
        let mut params = BTreeMap::new();
        params.insert("id".into(), "42".into());
        let req = FlowRequest::from_parts("GET", "/users/42", BTreeMap::new(), params, BTreeMap::new());
        let Path(id): Path<u64> = Path::from_request(&req).unwrap();
        assert_eq!(id, 42);
    }

    #[test]
    fn query_single_param() {
        let mut query = BTreeMap::new();
        query.insert("q".into(), "hello".into());
        let req = FlowRequest::from_parts("GET", "/", BTreeMap::new(), BTreeMap::new(), query);
        let Query(q): Query<String> = Query::from_request(&req).unwrap();
        assert_eq!(q, "hello");
    }
}