atomic_integration_proxy/
config.rs1use std::env;
2use url::Url;
3
4#[derive(Clone)]
11pub struct Config {
12 pub base_url: String,
18 pub port: u16,
19 pub session_secret: Option<String>,
23 pub catalog_path: String,
25 pub database_url: String,
28 pub encryption_key: String,
30 pub revoked_subjects: Vec<String>,
33 pub allowed_agents: Option<Vec<String>>,
36 pub operator_name: String,
39 pub operator_url: Option<String>,
42 pub key_check_limit_per_hour: u32,
47 pub trust_forwarded_for: TrustForwardedFor,
50}
51
52pub const DEFAULT_KEY_CHECK_LIMIT_PER_HOUR: u32 = 20;
56
57#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
60#[non_exhaustive]
61pub enum TrustForwardedFor {
62 #[default]
65 None,
66 RightMost,
74}
75
76impl std::str::FromStr for TrustForwardedFor {
77 type Err = String;
78
79 fn from_str(value: &str) -> Result<Self, String> {
80 match value.trim() {
81 "" | "none" => Ok(Self::None),
82 "heroku" | "rightmost" => Ok(Self::RightMost),
83 _ => Err("TRUST_FORWARDED_FOR must be `none`, `heroku` or `rightmost`".into()),
84 }
85 }
86}
87
88pub const MAX_KEY_CHECK_LIMIT_PER_HOUR: u32 = 10_000;
92
93pub(crate) fn key_check_limit(value: Option<&str>) -> Result<u32, String> {
98 let invalid = || {
99 format!(
100 "KEY_CHECK_LIMIT_PER_HOUR must be a whole number from 0 (no limit) to {MAX_KEY_CHECK_LIMIT_PER_HOUR}"
101 )
102 };
103 match value.map(str::trim) {
104 None | Some("") => Ok(DEFAULT_KEY_CHECK_LIMIT_PER_HOUR),
105 Some(value) => match value.parse::<u32>() {
106 Ok(limit) if limit <= MAX_KEY_CHECK_LIMIT_PER_HOUR => Ok(limit),
107 _ => Err(invalid()),
108 },
109 }
110}
111
112pub const DEFAULT_OPERATOR_NAME: &str = "this integration proxy";
115
116pub const OVERLAYS_PAGES_BASE: &str = "https://ontola.github.io/atomic-plugins/overlays/";
120
121#[cfg(test)]
125pub const DEFAULT_CATALOG_FILE: &str = "catalog/2026-10-02-auth-profiles.json";
126
127pub const DEFAULT_CATALOG_PATH: &str =
134 "https://ontola.github.io/atomic-plugins/overlays/catalog/2026-10-02-auth-profiles.json";
135
136fn require_env(name: &str) -> Result<String, String> {
140 match env::var(name) {
141 Ok(value) if !value.is_empty() => Ok(value),
142 _ => Err(format!("{name} must be set")),
143 }
144}
145
146fn list(value: &str) -> Vec<String> {
147 value
148 .split(',')
149 .map(str::trim)
150 .filter(|s| !s.is_empty())
151 .map(str::to_owned)
152 .collect()
153}
154
155pub(crate) fn validate_base_url(value: &str) -> Result<String, String> {
159 let url = Url::parse(value).map_err(|_| "BASE_URL must be an absolute URL".to_string())?;
160 if !matches!(url.scheme(), "https" | "http")
161 || url.host_str().is_none()
162 || !url.username().is_empty()
163 || url.password().is_some()
164 || url.query().is_some()
165 || url.fragment().is_some()
166 {
167 return Err(
168 "BASE_URL must be an http(s) URL without credentials, query or fragment".into(),
169 );
170 }
171 Ok(value.trim_end_matches('/').to_owned())
172}
173
174pub(crate) fn operator_name(value: Option<&str>) -> String {
176 match value.map(str::trim) {
177 Some(name) if !name.is_empty() => name.to_owned(),
178 _ => DEFAULT_OPERATOR_NAME.to_owned(),
179 }
180}
181
182pub(crate) fn validate_operator_url(value: Option<&str>) -> Result<Option<String>, String> {
186 let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) else {
187 return Ok(None);
188 };
189 let url = Url::parse(value)
190 .map_err(|_| "OPERATOR_URL must be an absolute http(s) URL".to_string())?;
191 if !matches!(url.scheme(), "https" | "http")
192 || url.host_str().is_none()
193 || !url.username().is_empty()
194 || url.password().is_some()
195 {
196 return Err("OPERATOR_URL must be an http(s) URL without credentials".into());
197 }
198 Ok(Some(url.to_string()))
199}
200
201pub(crate) fn public_host(base_url: &str) -> String {
204 match Url::parse(base_url) {
205 Ok(url) => match (url.host_str(), url.port()) {
206 (Some(host), Some(port)) => format!("{host}:{port}"),
207 (Some(host), None) => host.to_owned(),
208 _ => base_url.to_owned(),
209 },
210 Err(_) => base_url.to_owned(),
211 }
212}
213
214impl Config {
215 pub fn from_env() -> Result<Self, String> {
216 let base_url = validate_base_url(
217 &env::var("BASE_URL").unwrap_or_else(|_| "http://localhost:8080".to_string()),
218 )?;
219 let port = env::var("PORT")
220 .ok()
221 .and_then(|p| p.parse().ok())
222 .unwrap_or(8080);
223 let session_secret = env::var("SESSION_SECRET")
227 .ok()
228 .filter(|value| !value.is_empty());
229 let catalog_path =
230 env::var("CATALOG_PATH").unwrap_or_else(|_| DEFAULT_CATALOG_PATH.to_string());
231 let database_url = require_env("DATABASE_URL").map_err(|_| {
232 "DATABASE_URL must be set for connections and replay protection".to_string()
233 })?;
234 let encryption_key = require_env("ENCRYPTION_KEY")?;
235 let revoked_subjects = list(&env::var("REVOKED_SUBJECTS").unwrap_or_default());
236 let allowed_agents = env::var("ALLOWED_AGENTS")
237 .ok()
238 .filter(|value| !value.trim().is_empty())
239 .map(|value| list(&value));
240 let operator_name = operator_name(env::var("OPERATOR_NAME").ok().as_deref());
241 let operator_url = validate_operator_url(env::var("OPERATOR_URL").ok().as_deref())?;
242 let key_check_limit_per_hour =
243 key_check_limit(env::var("KEY_CHECK_LIMIT_PER_HOUR").ok().as_deref())?;
244 let trust_forwarded_for = env::var("TRUST_FORWARDED_FOR")
245 .unwrap_or_default()
246 .parse()?;
247
248 Ok(Self {
249 base_url,
250 port,
251 session_secret,
252 catalog_path,
253 database_url,
254 encryption_key,
255 revoked_subjects,
256 allowed_agents,
257 operator_name,
258 operator_url,
259 key_check_limit_per_hour,
260 trust_forwarded_for,
261 })
262 }
263
264 pub fn public_origin(&self) -> String {
267 Url::parse(&self.base_url)
268 .map(|url| url.origin().ascii_serialization())
269 .unwrap_or_else(|_| self.base_url.clone())
270 }
271
272 pub fn public_host(&self) -> String {
274 public_host(&self.base_url)
275 }
276
277 pub fn provider_env_prefix(provider: &str) -> Result<String, String> {
281 if provider.is_empty()
282 || !provider
283 .bytes()
284 .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
285 {
286 return Err(
287 "provider names may contain only lowercase letters, digits, and hyphens"
288 .to_string(),
289 );
290 }
291 Ok(format!(
292 "OAUTH_{}",
293 provider.replace('-', "_").to_ascii_uppercase()
294 ))
295 }
296}
297
298#[cfg(test)]
299mod tests {
300 use super::*;
301
302 #[test]
303 fn provider_names_produce_predictable_environment_prefixes() {
304 assert_eq!(
305 Config::provider_env_prefix("google-calendar").unwrap(),
306 "OAUTH_GOOGLE_CALENDAR"
307 );
308 assert!(Config::provider_env_prefix("Google Calendar").is_err());
309 }
310
311 #[test]
312 fn require_env_rejects_missing_and_blank_values() {
313 let name = "INTEGRATION_PROXY_TEST_REQUIRE_ENV_VAR";
314 env::remove_var(name);
315 assert!(require_env(name).is_err());
316 env::set_var(name, "");
317 assert!(require_env(name).is_err());
318 env::set_var(name, "a-value");
319 assert_eq!(require_env(name).unwrap(), "a-value");
320 env::remove_var(name);
321 }
322
323 #[test]
324 fn base_url_is_the_signed_origin_and_must_be_unambiguous() {
325 assert_eq!(
326 validate_base_url("https://proxy.example/").unwrap(),
327 "https://proxy.example"
328 );
329 assert_eq!(
330 validate_base_url("http://localhost:8080").unwrap(),
331 "http://localhost:8080"
332 );
333 for invalid in [
334 "proxy.example",
335 "ftp://proxy.example",
336 "https://u:p@proxy.example",
337 "https://proxy.example?x=1",
338 "https://proxy.example#x",
339 ] {
340 assert!(validate_base_url(invalid).is_err(), "{invalid}");
341 }
342 let config = Config {
343 base_url: "https://proxy.example:8443/prefix".into(),
344 port: 0,
345 session_secret: None,
346 catalog_path: String::new(),
347 database_url: String::new(),
348 encryption_key: String::new(),
349 revoked_subjects: vec![],
350 allowed_agents: None,
351 operator_name: DEFAULT_OPERATOR_NAME.into(),
352 operator_url: None,
353 key_check_limit_per_hour: 0,
354 trust_forwarded_for: TrustForwardedFor::None,
355 };
356 assert_eq!(config.public_origin(), "https://proxy.example:8443");
357 assert_eq!(config.public_host(), "proxy.example:8443");
358 assert_eq!(public_host("https://proxy.example"), "proxy.example");
359 assert_eq!(public_host("http://127.0.0.1:8080"), "127.0.0.1:8080");
360 }
361
362 #[test]
363 fn operator_name_defaults_to_a_neutral_phrase() {
364 assert_eq!(operator_name(None), DEFAULT_OPERATOR_NAME);
365 assert_eq!(operator_name(Some(" ")), DEFAULT_OPERATOR_NAME);
366 assert_eq!(operator_name(Some(" Atomic Data ")), "Atomic Data");
367 }
368
369 #[test]
370 fn operator_url_is_optional_and_must_be_a_plain_http_url() {
371 assert_eq!(validate_operator_url(None).unwrap(), None);
372 assert_eq!(validate_operator_url(Some(" ")).unwrap(), None);
373 assert_eq!(
374 validate_operator_url(Some("https://atomic.place")).unwrap(),
375 Some("https://atomic.place/".into())
376 );
377 for invalid in [
378 "atomic.place",
379 "javascript:alert(1)",
380 "data:text/html,x",
381 "https://u:p@atomic.place",
382 ] {
383 assert!(validate_operator_url(Some(invalid)).is_err(), "{invalid}");
384 }
385 }
386
387 #[test]
388 fn the_key_check_limit_defaults_to_twenty_and_zero_turns_it_off() {
389 assert_eq!(key_check_limit(None).unwrap(), 20);
390 assert_eq!(key_check_limit(Some(" ")).unwrap(), 20);
391 assert_eq!(key_check_limit(Some("0")).unwrap(), 0);
392 assert_eq!(key_check_limit(Some(" 50 ")).unwrap(), 50);
393 assert_eq!(key_check_limit(Some("10000")).unwrap(), 10_000);
394 for invalid in ["-1", "twenty", "1.5", "10001", "2000000", "99999999999"] {
395 let error = key_check_limit(Some(invalid)).unwrap_err();
396 assert!(
397 error.contains("0 (no limit) to 10000"),
398 "{invalid}: {error}"
399 );
400 }
401 }
402
403 #[test]
404 fn forwarded_for_is_trusted_only_when_named() {
405 assert_eq!("".parse(), Ok(TrustForwardedFor::None));
406 assert_eq!("none".parse(), Ok(TrustForwardedFor::None));
407 assert_eq!(" heroku ".parse(), Ok(TrustForwardedFor::RightMost));
408 assert_eq!("rightmost".parse(), Ok(TrustForwardedFor::RightMost));
409 for invalid in ["Heroku", "true", "all", "x-forwarded-for"] {
410 assert!(invalid.parse::<TrustForwardedFor>().is_err(), "{invalid}");
411 }
412 }
413
414 #[test]
415 fn lists_are_comma_separated_and_trimmed() {
416 assert_eq!(list(" a, b ,,c "), vec!["a", "b", "c"]);
417 assert!(list("").is_empty());
418 }
419}