1use crate::api::query::Query;
28use axum::response::{IntoResponse, Response};
29use axum::Json;
30use rustango::core::Column as _;
31use rustango::extractors::{SessionUser, Tenant};
32use rustango::sql::FetcherPool as _;
33use serde::Deserialize;
34
35use crate::page::Page;
36
37pub const DEFAULT_DEPTH: i64 = 3;
41pub const MAX_DEPTH: i64 = 10;
43pub const MAX_NODES: usize = 5_000;
46
47#[derive(Debug, Default, Deserialize)]
48pub struct TreeQuery {
49 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
52 pub root: Option<i64>,
53 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
55 pub depth: Option<i64>,
56 #[serde(default, deserialize_with = "crate::api::query::empty_string_as_none")]
59 pub locale: Option<String>,
60}
61
62pub async fn tree(
64 tenant: Tenant,
65 SessionUser(session_user): SessionUser,
66 rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
67 crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
68 Query(q): Query<TreeQuery>,
69) -> Response {
70 let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
73 match tree_inner(tenant.pool(), viewer, &q).await {
74 Ok(resp) => resp,
75 Err(e) => {
76 tracing::error!(target: "rustango_cms::api", error = %e, "page tree failed");
77 crate::api::error::ApiError::internal().into_response()
78 }
79 }
80}
81
82pub async fn tree_inner(
87 pool: &rustango::sql::Pool,
88 viewer: Option<&rustango::tenancy::auth::User>,
89 q: &TreeQuery,
90) -> Result<Response, rustango::sql::ExecError> {
91 let depth = q.depth.unwrap_or(DEFAULT_DEPTH).clamp(1, MAX_DEPTH);
92
93 let statuses = [
98 crate::page::PageStatus::Published.as_str().to_owned(),
99 crate::page::PageStatus::Archived.as_str().to_owned(),
100 ];
101 let mut rows: Vec<Page> = Page::objects()
102 .where_(Page::status.is_in(statuses))
103 .order_by(&[("path", false)])
106 .fetch(pool)
107 .await?;
108
109 rows.sort_by_key(|p| (p.sort_order, p.id.get().copied().unwrap_or_default()));
117
118 let error_tid = crate::error_pages::error_page_type_id(pool).await;
121 rows.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
122
123 rows.retain(|p| p.locale_variant_of.is_none());
127
128 let triples: Vec<(i64, String, i64)> = rows
133 .iter()
134 .map(|p| {
135 (
136 p.id.get().copied().unwrap_or_default(),
137 p.path.clone(),
138 p.page_type_id,
139 )
140 })
141 .collect();
142 let denied = crate::view_restriction::denied_page_ids(pool, viewer, &triples).await;
143 if !denied.is_empty() {
144 rows.retain(|p| !denied.contains(&p.id.get().copied().unwrap_or_default()));
145 }
146
147 let root_parent = match q.root {
150 Some(root_id) => {
151 let Some(root) = rows
152 .iter()
153 .find(|p| p.id.get().copied() == Some(root_id))
154 .cloned()
155 else {
156 return Ok(
159 crate::api::error::ApiError::not_found("page").into_response()
160 );
161 };
162 let prefix = root.path.clone();
163 rows.retain(|p| p.path.starts_with(&prefix) && p.path != prefix);
164 Some(root_id)
165 }
166 None => None,
167 };
168
169 let alias_sources: Vec<i64> = rows.iter().filter_map(|p| p.alias_of).collect();
174 let alias_titles: std::collections::HashMap<i64, String> = if alias_sources.is_empty() {
175 std::collections::HashMap::new()
176 } else {
177 let sources: Vec<Page> = Page::objects()
178 .where_(Page::id.is_in(alias_sources))
179 .fetch(pool)
180 .await?;
181 let src_triples: Vec<(i64, String, i64)> = sources
188 .iter()
189 .map(|p| {
190 (
191 p.id.get().copied().unwrap_or_default(),
192 p.path.clone(),
193 p.page_type_id,
194 )
195 })
196 .collect();
197 let src_denied =
198 crate::view_restriction::denied_page_ids(pool, viewer, &src_triples).await;
199 sources
200 .into_iter()
201 .filter(|p| {
202 p.status == crate::page::PageStatus::Published.as_str()
203 || p.status == crate::page::PageStatus::Archived.as_str()
204 })
205 .filter_map(|p| p.id.get().copied().map(|id| (id, p.title)))
206 .filter(|(id, _)| !src_denied.contains(id))
207 .collect()
208 };
209
210 let type_names = crate::api::pages::page_type_names(pool).await?;
214
215 let locale = crate::translation::resolve_locale(pool, q.locale.as_deref()).await?;
217 let translations = match locale.as_ref().filter(|l| !l.is_default) {
218 Some(l) => {
219 let lid = l.id.get().copied().unwrap_or_default();
220 let ids: Vec<i64> = rows
221 .iter()
222 .filter_map(|p| p.id.get().copied())
223 .chain(alias_titles.keys().copied())
224 .collect();
225 crate::translation::fetch_for_pages(pool, &ids, lid)
226 .await
227 .unwrap_or_default()
228 }
229 _ => std::collections::HashMap::new(),
230 };
231
232 let mut child_count: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
236 for p in &rows {
237 if let Some(pid) = p.parent_id {
238 *child_count.entry(pid).or_default() += 1;
239 }
240 }
241
242 let by_parent = crate::tree_build::index_by_parent(&rows, |p| {
243 if p.parent_id == root_parent {
245 None
246 } else {
247 p.parent_id
248 }
249 });
250
251 let emitted = std::cell::Cell::new(0usize);
254 let nodes = crate::tree_build::build(
255 &by_parent,
256 None,
257 depth,
258 &|p: &Page| p.id.get().copied().unwrap_or_default(),
259 &|p: &Page, children: Vec<serde_json::Value>| {
260 emitted.set(emitted.get() + 1);
261 node_json(
262 p,
263 children,
264 &alias_titles,
265 &translations,
266 &child_count,
267 &type_names,
268 )
269 },
270 );
271 let emitted = emitted.get();
272 let truncated = emitted > MAX_NODES;
273 let mut nodes = nodes;
274 if truncated {
275 let mut budget = MAX_NODES;
280 prune(&mut nodes, &mut budget);
281 }
282
283 Ok(Json(serde_json::json!({
284 "meta": {
285 "depth": depth,
286 "root": q.root,
287 "locale": locale.as_ref().map(|l| l.code.clone()),
288 "total_count": emitted.min(MAX_NODES),
289 "truncated": truncated,
290 "dropped_count": emitted.saturating_sub(MAX_NODES),
295 },
296 "items": nodes,
297 }))
298 .into_response())
299}
300
301fn prune(nodes: &mut Vec<serde_json::Value>, budget: &mut usize) {
305 let keep = nodes.len().min(*budget);
306 nodes.truncate(keep);
307 *budget -= keep;
308 for n in nodes.iter_mut() {
309 let Some(children) = n.get_mut("children").and_then(|c| c.as_array_mut()) else {
310 continue;
311 };
312 prune(children, budget);
313 }
314}
315
316fn node_json(
320 p: &Page,
321 children: Vec<serde_json::Value>,
322 alias_titles: &std::collections::HashMap<i64, String>,
323 translations: &std::collections::HashMap<i64, std::collections::HashMap<String, String>>,
324 child_count: &std::collections::HashMap<i64, usize>,
325 type_names: &std::collections::HashMap<i64, String>,
326) -> serde_json::Value {
327 let id = p.id.get().copied().unwrap_or_default();
328 let source_id = p.alias_of.unwrap_or(id);
331 let base_title = p
332 .alias_of
333 .and_then(|src| alias_titles.get(&src).cloned())
334 .unwrap_or_else(|| p.title.clone());
335 let title = translations
336 .get(&source_id)
337 .and_then(|m| m.get("title"))
338 .filter(|s| !s.is_empty())
339 .cloned()
340 .unwrap_or(base_title);
341
342 let mut obj = serde_json::json!({
343 "id": id,
344 "title": title,
345 "type": type_names.get(&p.page_type_id).cloned().unwrap_or_default(),
346 "slug": p.slug,
347 "url": if p.url_path.is_empty() { "/" } else { p.url_path.as_str() },
348 "depth": p.depth,
349 "has_children": child_count.get(&id).copied().unwrap_or(0) > 0,
350 "detail_url": format!("/api/v2/pages/{id}/"),
351 "children": children,
352 });
353 if let Some(src) = p.alias_of {
354 obj["alias_of"] = serde_json::json!(src);
357 }
358 obj
359}
360
361#[cfg(test)]
362mod tests {
363 use super::*;
364 use serde_json::json;
365
366 fn sample() -> Vec<serde_json::Value> {
368 vec![
369 json!({"id": 1, "children": [
370 {"id": 2, "children": []},
371 {"id": 3, "children": []},
372 ]}),
373 json!({"id": 4, "children": []}),
374 ]
375 }
376
377 fn ids(nodes: &[serde_json::Value]) -> Vec<i64> {
378 let mut out = Vec::new();
379 for n in nodes {
380 out.push(n["id"].as_i64().unwrap());
381 out.extend(ids(n["children"].as_array().unwrap()));
382 }
383 out
384 }
385
386 #[test]
387 fn prune_counts_descendants_not_just_roots() {
388 let mut nodes = sample();
391 let mut budget = 3;
392 prune(&mut nodes, &mut budget);
393 assert_eq!(ids(&nodes).len(), 3);
394 }
395
396 #[test]
397 fn prune_keeps_a_breadth_then_depth_prefix() {
398 let mut nodes = sample();
399 let mut budget = 3;
400 prune(&mut nodes, &mut budget);
401 assert_eq!(ids(&nodes), vec![1, 2, 4]);
403 }
404
405 #[test]
406 fn prune_under_budget_changes_nothing() {
407 let mut nodes = sample();
408 let mut budget = MAX_NODES;
409 prune(&mut nodes, &mut budget);
410 assert_eq!(ids(&nodes), vec![1, 2, 3, 4]);
411 }
412
413 #[test]
414 fn a_zero_budget_empties_the_tree() {
415 let mut nodes = sample();
416 let mut budget = 0;
417 prune(&mut nodes, &mut budget);
418 assert!(nodes.is_empty());
419 }
420
421 #[test]
422 fn depth_is_clamped_to_the_ceiling() {
423 for (asked, want) in [(None, DEFAULT_DEPTH), (Some(999), MAX_DEPTH), (Some(0), 1)] {
425 let got = asked.unwrap_or(DEFAULT_DEPTH).clamp(1, MAX_DEPTH);
426 assert_eq!(got, want, "depth={asked:?}");
427 }
428 }
429}