Skip to main content

elemental_driver/url/
policy.rs

1use std::collections::HashMap;
2
3use elemental_infra::SafeRelativePath;
4use reqwest::Url;
5
6use super::Origin;
7use super::util::{require_http_scheme, trim_trailing_slash, with_directory_path};
8use crate::error::{Error, Result};
9
10#[derive(Debug, Clone)]
11pub struct OriginPolicy<O: Origin> {
12    pub(super) overrides: HashMap<O, Url>,
13}
14
15impl<O: Origin> Default for OriginPolicy<O> {
16    fn default() -> Self {
17        Self {
18            overrides: HashMap::new(),
19        }
20    }
21}
22
23impl<O: Origin> OriginPolicy<O> {
24    pub fn new(overrides: HashMap<O, Url>) -> Result<Self> {
25        for url in overrides.values() {
26            require_http_scheme(url, "origin override")?;
27        }
28        Ok(Self { overrides })
29    }
30
31    pub fn with_override(mut self, origin: O, raw_url: String) -> Result<Self> {
32        self.override_origin(origin, raw_url)?;
33        Ok(self)
34    }
35
36    pub fn override_origin(&mut self, origin: O, raw_url: String) -> Result<()> {
37        let url = Url::parse(&raw_url).map_err(move |source| {
38            Error::invalid_url("parse origin override failed", raw_url, source)
39        })?;
40        require_http_scheme(&url, "origin override")?;
41        self.overrides.insert(origin, url);
42        Ok(())
43    }
44
45    /// Layers `overrides` on top of the current policy.
46    pub fn merged_with(&self, overrides: &Self) -> Self {
47        let mut merged = self.clone();
48        merged.overrides.extend(
49            overrides
50                .overrides
51                .iter()
52                .map(|(origin, url)| (*origin, url.clone())),
53        );
54        merged
55    }
56
57    pub fn base_url(&self, origin: O) -> Result<Url> {
58        let url = match self.overrides.get(&origin) {
59            Some(url) => url.clone(),
60            None => Url::parse(origin.canonical()).map_err(|source| {
61                Error::invalid_url("parse canonical origin failed", origin.canonical(), source)
62            })?,
63        };
64
65        with_directory_path(url)
66    }
67
68    pub fn resolve(&self, origin: O, path: &str) -> Result<String> {
69        let base = self.base_url(origin)?;
70        let suffix = path.trim_start_matches('/');
71        if suffix.is_empty() {
72            return Ok(trim_trailing_slash(base.as_str()).to_owned());
73        }
74        let suffix = SafeRelativePath::parse(suffix)?;
75
76        base.join(suffix.as_str())
77            .map_err(|source| {
78                Error::join_url("resolve origin path failed", base.as_str(), path, source)
79            })
80            .map(|url| url.to_string())
81    }
82
83    pub fn resolve_segments<const N: usize>(
84        &self,
85        origin: O,
86        segments: [&str; N],
87    ) -> Result<String> {
88        let mut url = self.base_url(origin)?;
89        let raw_url = url.to_string();
90        {
91            let mut path_segments = url
92                .path_segments_mut()
93                .map_err(|()| Error::UrlNotPathBase { url: raw_url })?;
94            for segment in segments {
95                path_segments.push(segment);
96            }
97        }
98
99        Ok(url.to_string())
100    }
101}