better_fetch/
url_build.rs

1use std::borrow::Cow;
2use std::collections::HashMap;
3
4use http::Method;
5use indexmap::IndexMap;
6use percent_encoding::{AsciiSet, utf8_percent_encode, NON_ALPHANUMERIC};
7use url::Url;
8
9use crate::error::Error;
10use crate::Result;
11
12/// RFC 3986 unreserved — same set as the former inline path param encoder.
13const PATH_PARAM_ENCODE: &AsciiSet = &NON_ALPHANUMERIC
14    .remove(b'-')
15    .remove(b'_')
16    .remove(b'.')
17    .remove(b'~');
18
19/// Result of building a request URL.
20#[derive(Debug, Clone)]
21pub struct BuiltUrl {
22    pub url: Url,
23    pub method_override: Option<Method>,
24}
25
26/// Build a request URL from base URL, path template, params, and query.
27///
28/// Query keys are serialized in insertion order ([`IndexMap`]).
29pub fn build_url(
30    base: &Url,
31    path: &str,
32    params: &HashMap<String, String>,
33    query: &IndexMap<String, QueryValue>,
34) -> Result<BuiltUrl> {
35    if path.starts_with("http://") || path.starts_with("https://") {
36        let (path_only, method_override) = parse_method_modifier(path);
37        let resolved_path = substitute_params(path_only, params)?;
38        let mut url = Url::parse(&resolved_path).map_err(Error::InvalidBaseUrl)?;
39        apply_query(&mut url, query)?;
40        return Ok(BuiltUrl {
41            url,
42            method_override,
43        });
44    }
45
46    let (path_only, method_override) = parse_method_modifier(path);
47    let resolved_path = substitute_params(path_only, params)?;
48    let mut url = join_path(base, &resolved_path)?;
49    apply_query(&mut url, query)?;
50
51    Ok(BuiltUrl {
52        url,
53        method_override,
54    })
55}
56
57fn apply_query(url: &mut Url, query: &IndexMap<String, QueryValue>) -> Result<()> {
58    if query.is_empty() {
59        return Ok(());
60    }
61    let mut pairs = url::form_urlencoded::Serializer::new(String::new());
62    for (key, value) in query {
63        match value {
64            QueryValue::Scalar(v) => {
65                pairs.append_pair(key, v);
66            }
67            QueryValue::Array(values) => {
68                for v in values {
69                    pairs.append_pair(key, v);
70                }
71            }
72        }
73    }
74    let query_string = pairs.finish();
75    url.set_query(Some(&query_string));
76    Ok(())
77}
78
79/// Parse `@put/foo` style path modifiers; returns stripped path and optional HTTP method.
80pub fn parse_method_modifier(path: &str) -> (&str, Option<Method>) {
81    if let Some(rest) = path.strip_prefix('@') {
82        if let Some((method, remainder)) = rest.split_once('/') {
83            let m = match method.to_ascii_lowercase().as_str() {
84                "get" => Some(Method::GET),
85                "post" => Some(Method::POST),
86                "put" => Some(Method::PUT),
87                "patch" => Some(Method::PATCH),
88                "delete" => Some(Method::DELETE),
89                "head" => Some(Method::HEAD),
90                _ => None,
91            };
92            if m.is_some() {
93                return (remainder.trim_start_matches('/'), m);
94            }
95        }
96    }
97    (path, None)
98}
99
100fn substitute_params(path: &str, params: &HashMap<String, String>) -> Result<String> {
101    let mut result = path.to_string();
102    for (key, value) in params {
103        let placeholder = format!(":{key}");
104        if !result.contains(&placeholder) {
105            continue;
106        }
107        let encoded: Cow<'_, str> = utf8_percent_encode(value, PATH_PARAM_ENCODE).into();
108        result = result.replace(&placeholder, encoded.as_ref());
109    }
110
111    if result.contains(':') {
112        for segment in result.split('/') {
113            if segment.starts_with(':') {
114                return Err(Error::Other(format!(
115                    "missing path parameter for `{}`",
116                    segment
117                )));
118            }
119        }
120    }
121
122    Ok(result)
123}
124
125fn join_path(base: &Url, path: &str) -> Result<Url> {
126    let path = path.trim_start_matches('/');
127    let base_str = base.as_str().trim_end_matches('/');
128    let joined = if path.is_empty() {
129        base_str.to_string()
130    } else {
131        format!("{base_str}/{path}")
132    };
133    Url::parse(&joined).map_err(Error::InvalidBaseUrl)
134}
135
136/// Query parameter value (scalar or repeated).
137#[derive(Debug, Clone)]
138pub enum QueryValue {
139    Scalar(String),
140    Array(Vec<String>),
141}
142
143impl QueryValue {
144    #[cfg(feature = "json")]
145    pub fn from_serializable<T: serde::Serialize>(value: &T) -> Result<Self> {
146        match serde_json::to_value(value).map_err(|e| Error::Other(e.to_string()))? {
147            serde_json::Value::String(s) => Ok(Self::Scalar(s)),
148            serde_json::Value::Number(n) => Ok(Self::Scalar(n.to_string())),
149            serde_json::Value::Bool(b) => Ok(Self::Scalar(b.to_string())),
150            serde_json::Value::Array(arr) => {
151                let values: Vec<String> = arr
152                    .into_iter()
153                    .map(|v| match v {
154                        serde_json::Value::String(s) => s,
155                        other => other.to_string(),
156                    })
157                    .collect();
158                Ok(Self::Array(values))
159            }
160            other => Ok(Self::Scalar(other.to_string())),
161        }
162    }
163}
164
165#[cfg(test)]
166mod tests {
167    use super::*;
168
169    fn base() -> Url {
170        Url::parse("https://api.example.com").unwrap()
171    }
172
173    #[test]
174    fn substitutes_colon_params() {
175        let mut params = HashMap::new();
176        params.insert("id".into(), "42".into());
177        let built = build_url(&base(), "/todos/:id", &params, &IndexMap::new()).unwrap();
178        assert_eq!(built.url.as_str(), "https://api.example.com/todos/42");
179    }
180
181    #[test]
182    fn multiple_params() {
183        let mut params = HashMap::new();
184        params.insert("id".into(), "1".into());
185        params.insert("title".into(), "hello".into());
186        let built = build_url(&base(), "/post/:id/:title", &params, &IndexMap::new()).unwrap();
187        assert_eq!(built.url.as_str(), "https://api.example.com/post/1/hello");
188    }
189
190    #[test]
191    fn encodes_special_characters_in_params() {
192        let mut params = HashMap::new();
193        params.insert("id".into(), "a/b".into());
194        let built = build_url(&base(), "/items/:id", &params, &IndexMap::new()).unwrap();
195        assert!(built.url.path().contains("a%2Fb"));
196    }
197
198    #[test]
199    fn missing_param_errors() {
200        let err = build_url(&base(), "/todos/:id", &HashMap::new(), &IndexMap::new()).unwrap_err();
201        assert!(matches!(err, Error::Other(_)));
202    }
203
204    #[test]
205    fn query_scalar() {
206        let mut query = IndexMap::new();
207        query.insert("q".into(), QueryValue::Scalar("rust".into()));
208        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
209        assert_eq!(built.url.query(), Some("q=rust"));
210    }
211
212    #[test]
213    fn query_array() {
214        let mut query = IndexMap::new();
215        query.insert(
216            "tag".into(),
217            QueryValue::Array(vec!["a".into(), "b".into()]),
218        );
219        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
220        let q = built.url.query().unwrap();
221        assert!(q.contains("tag=a"));
222        assert!(q.contains("tag=b"));
223    }
224
225    #[test]
226    fn query_preserves_insertion_order() {
227        let mut query = IndexMap::new();
228        query.insert("z".into(), QueryValue::Scalar("1".into()));
229        query.insert("a".into(), QueryValue::Scalar("2".into()));
230        query.insert("m".into(), QueryValue::Scalar("3".into()));
231        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
232        assert_eq!(built.url.query(), Some("z=1&a=2&m=3"));
233    }
234
235    #[test]
236    fn method_modifier_put() {
237        let (path, method) = parse_method_modifier("@put/user");
238        assert_eq!(path, "user");
239        assert_eq!(method, Some(Method::PUT));
240    }
241
242    #[test]
243    fn method_modifier_in_build_url() {
244        let built = build_url(&base(), "@patch/items", &HashMap::new(), &IndexMap::new()).unwrap();
245        assert_eq!(built.url.path(), "/items");
246        assert_eq!(built.method_override, Some(Method::PATCH));
247    }
248
249    #[test]
250    fn absolute_url_ignores_base() {
251        let mut params = HashMap::new();
252        params.insert("id".into(), "5".into());
253        let built = build_url(
254            &base(),
255            "https://other.example.com/users/:id",
256            &params,
257            &IndexMap::new(),
258        )
259        .unwrap();
260        assert_eq!(built.url.as_str(), "https://other.example.com/users/5");
261    }
262
263    #[test]
264    fn empty_path_uses_base() {
265        let built = build_url(&base(), "", &HashMap::new(), &IndexMap::new()).unwrap();
266        assert_eq!(built.url.as_str(), "https://api.example.com/");
267    }
268}
269
270#[cfg(test)]
271mod proptests {
272    use super::*;
273    use proptest::prelude::*;
274
275    proptest! {
276        #[test]
277        fn substitute_preserves_literal_segments(path in r"([a-z]+/)*[a-z]+") {
278            let mut params = HashMap::new();
279            params.insert("id".into(), "42".into());
280            let template = format!("/{path}/:id");
281            let built = build_url(
282                &Url::parse("https://api.example.com").unwrap(),
283                &template,
284                &params,
285                &IndexMap::new(),
286            )
287            .unwrap();
288            prop_assert!(built.url.as_str().ends_with("/42"));
289        }
290    }
291}
better_fetch/url_build.rs

better_fetch/
url_build.rs
