Skip to main content

seam_server/build_loader/
types.rs

1/* src/server/core/rust/src/build_loader/types.rs */
2
3use std::collections::HashMap;
4
5use serde::Deserialize;
6
7#[derive(Deserialize)]
8pub(super) struct RouteManifest {
9	#[serde(default)]
10	pub(super) layouts: HashMap<String, LayoutEntry>,
11	pub(super) routes: HashMap<String, RouteEntry>,
12	#[serde(default)]
13	pub(super) data_id: Option<String>,
14	#[serde(default)]
15	pub(super) i18n: Option<I18nManifest>,
16}
17
18#[derive(Deserialize)]
19pub(super) struct I18nManifest {
20	#[serde(default)]
21	pub(super) locales: Vec<String>,
22	#[serde(default)]
23	pub(super) default: String,
24	#[serde(default)]
25	pub(super) mode: Option<String>,
26	#[serde(default)]
27	pub(super) cache: bool,
28	#[serde(default)]
29	pub(super) route_hashes: HashMap<String, String>,
30	#[serde(default)]
31	pub(super) content_hashes: HashMap<String, HashMap<String, String>>,
32}
33
34#[derive(Deserialize)]
35pub(super) struct LayoutEntry {
36	pub(super) template: Option<String>,
37	#[serde(default)]
38	pub(super) templates: Option<HashMap<String, String>>,
39	#[serde(default)]
40	pub(super) loaders: serde_json::Value,
41	#[serde(default)]
42	pub(super) parent: Option<String>,
43	#[serde(default)]
44	pub(super) i18n_keys: Vec<String>,
45}
46
47#[derive(Deserialize)]
48pub(super) struct RouteEntry {
49	pub(super) template: Option<String>,
50	#[serde(default)]
51	pub(super) templates: Option<HashMap<String, String>>,
52	#[serde(default)]
53	pub(super) layout: Option<String>,
54	#[serde(default)]
55	pub(super) loaders: serde_json::Value,
56	#[serde(default)]
57	pub(super) head_meta: Option<String>,
58	#[serde(default)]
59	pub(super) i18n_keys: Vec<String>,
60	#[serde(default)]
61	pub(super) projections: Option<HashMap<String, Vec<String>>>,
62	#[serde(default)]
63	pub(super) prerender: Option<bool>,
64}
65
66/// Pick a template path: prefer singular `template`, fall back to default locale or first value.
67pub(super) fn pick_template(
68	single: &Option<String>,
69	multi: &Option<HashMap<String, String>>,
70	default_locale: Option<&str>,
71) -> Option<String> {
72	if let Some(t) = single {
73		return Some(t.clone());
74	}
75	if let Some(map) = multi {
76		// Prefer the default locale from manifest
77		if let Some(loc) = default_locale
78			&& let Some(t) = map.get(loc)
79		{
80			return Some(t.clone());
81		}
82		return map.values().next().cloned();
83	}
84	None
85}
86
87#[derive(Deserialize)]
88pub(super) struct LoaderConfig {
89	pub(super) procedure: String,
90	#[serde(default)]
91	pub(super) params: HashMap<String, ParamConfig>,
92}
93
94/// Supports both string shorthand `"route"` and full object `{ "from": "route", "type": "int" }`.
95pub(super) struct ParamConfig {
96	pub(super) from: String,
97	pub(super) param_type: String,
98}
99
100pub(super) fn default_type() -> String {
101	"string".to_string()
102}
103
104impl<'de> serde::Deserialize<'de> for ParamConfig {
105	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
106	where
107		D: serde::Deserializer<'de>,
108	{
109		let value = serde_json::Value::deserialize(deserializer)?;
110		match value {
111			serde_json::Value::String(s) => Ok(ParamConfig { from: s, param_type: default_type() }),
112			serde_json::Value::Object(map) => {
113				let from = map
114					.get("from")
115					.and_then(|v| v.as_str())
116					.ok_or_else(|| serde::de::Error::missing_field("from"))?
117					.to_string();
118				let param_type =
119					map.get("type").and_then(|v| v.as_str()).map(String::from).unwrap_or_else(default_type);
120				Ok(ParamConfig { from, param_type })
121			}
122			_ => Err(serde::de::Error::custom("expected string or object")),
123		}
124	}
125}
126
127/// RPC hash map loaded from build output. Maps hashed names back to original procedure names.
128#[derive(Deserialize, Clone, Debug)]
129pub struct RpcHashMap {
130	pub salt: String,
131	pub batch: String,
132	pub procedures: HashMap<String, String>,
133}
134
135impl RpcHashMap {
136	/// Build a reverse lookup: hash -> original name
137	pub fn reverse_lookup(&self) -> HashMap<String, String> {
138		self.procedures.iter().map(|(name, hash)| (hash.clone(), name.clone())).collect()
139	}
140}