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    /// Single query value.
140    Scalar(String),
141    /// Repeated query key (`key=a&key=b`).
142    Array(Vec<String>),
143}
144
145impl QueryValue {
146    /// Encodes a serializable value as a scalar or array query param (feature `json`).
147    #[cfg(feature = "json")]
148    pub fn from_serializable<T: serde::Serialize>(value: &T) -> Result<Self> {
149        match serde_json::to_value(value).map_err(|e| Error::Other(e.to_string()))? {
150            serde_json::Value::String(s) => Ok(Self::Scalar(s)),
151            serde_json::Value::Number(n) => Ok(Self::Scalar(n.to_string())),
152            serde_json::Value::Bool(b) => Ok(Self::Scalar(b.to_string())),
153            serde_json::Value::Array(arr) => {
154                let values: Vec<String> = arr
155                    .into_iter()
156                    .map(|v| match v {
157                        serde_json::Value::String(s) => s,
158                        other => other.to_string(),
159                    })
160                    .collect();
161                Ok(Self::Array(values))
162            }
163            other => Ok(Self::Scalar(other.to_string())),
164        }
165    }
166}
167
168#[cfg(test)]
169mod tests {
170    use super::*;
171
172    fn base() -> Url {
173        Url::parse("https://api.example.com").unwrap()
174    }
175
176    #[test]
177    fn substitutes_colon_params() {
178        let mut params = HashMap::new();
179        params.insert("id".into(), "42".into());
180        let built = build_url(&base(), "/todos/:id", &params, &IndexMap::new()).unwrap();
181        assert_eq!(built.url.as_str(), "https://api.example.com/todos/42");
182    }
183
184    #[test]
185    fn multiple_params() {
186        let mut params = HashMap::new();
187        params.insert("id".into(), "1".into());
188        params.insert("title".into(), "hello".into());
189        let built = build_url(&base(), "/post/:id/:title", &params, &IndexMap::new()).unwrap();
190        assert_eq!(built.url.as_str(), "https://api.example.com/post/1/hello");
191    }
192
193    #[test]
194    fn encodes_special_characters_in_params() {
195        let mut params = HashMap::new();
196        params.insert("id".into(), "a/b".into());
197        let built = build_url(&base(), "/items/:id", &params, &IndexMap::new()).unwrap();
198        assert!(built.url.path().contains("a%2Fb"));
199    }
200
201    #[test]
202    fn missing_param_errors() {
203        let err = build_url(&base(), "/todos/:id", &HashMap::new(), &IndexMap::new()).unwrap_err();
204        assert!(matches!(err, Error::Other(_)));
205    }
206
207    #[test]
208    fn query_scalar() {
209        let mut query = IndexMap::new();
210        query.insert("q".into(), QueryValue::Scalar("rust".into()));
211        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
212        assert_eq!(built.url.query(), Some("q=rust"));
213    }
214
215    #[test]
216    fn query_array() {
217        let mut query = IndexMap::new();
218        query.insert(
219            "tag".into(),
220            QueryValue::Array(vec!["a".into(), "b".into()]),
221        );
222        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
223        let q = built.url.query().unwrap();
224        assert!(q.contains("tag=a"));
225        assert!(q.contains("tag=b"));
226    }
227
228    #[test]
229    fn query_preserves_insertion_order() {
230        let mut query = IndexMap::new();
231        query.insert("z".into(), QueryValue::Scalar("1".into()));
232        query.insert("a".into(), QueryValue::Scalar("2".into()));
233        query.insert("m".into(), QueryValue::Scalar("3".into()));
234        let built = build_url(&base(), "/search", &HashMap::new(), &query).unwrap();
235        assert_eq!(built.url.query(), Some("z=1&a=2&m=3"));
236    }
237
238    #[test]
239    fn method_modifier_put() {
240        let (path, method) = parse_method_modifier("@put/user");
241        assert_eq!(path, "user");
242        assert_eq!(method, Some(Method::PUT));
243    }
244
245    #[test]
246    fn method_modifier_in_build_url() {
247        let built = build_url(&base(), "@patch/items", &HashMap::new(), &IndexMap::new()).unwrap();
248        assert_eq!(built.url.path(), "/items");
249        assert_eq!(built.method_override, Some(Method::PATCH));
250    }
251
252    #[test]
253    fn absolute_url_ignores_base() {
254        let mut params = HashMap::new();
255        params.insert("id".into(), "5".into());
256        let built = build_url(
257            &base(),
258            "https://other.example.com/users/:id",
259            &params,
260            &IndexMap::new(),
261        )
262        .unwrap();
263        assert_eq!(built.url.as_str(), "https://other.example.com/users/5");
264    }
265
266    #[test]
267    fn empty_path_uses_base() {
268        let built = build_url(&base(), "", &HashMap::new(), &IndexMap::new()).unwrap();
269        assert_eq!(built.url.as_str(), "https://api.example.com/");
270    }
271}
272
273#[cfg(test)]
274mod proptests {
275    use super::*;
276    use proptest::prelude::*;
277
278    proptest! {
279        #[test]
280        fn substitute_preserves_literal_segments(path in r"([a-z]+/)*[a-z]+") {
281            let mut params = HashMap::new();
282            params.insert("id".into(), "42".into());
283            let template = format!("/{path}/:id");
284            let built = build_url(
285                &Url::parse("https://api.example.com").unwrap(),
286                &template,
287                &params,
288                &IndexMap::new(),
289            )
290            .unwrap();
291            prop_assert!(built.url.as_str().ends_with("/42"));
292        }
293    }
294}
better_fetch/url_build.rs

better_fetch/
url_build.rs
