use crate::api::query::Query;
use axum::response::{IntoResponse, Response};
use axum::Json;
use rustango::core::Column as _;
use rustango::extractors::{SessionUser, Tenant};
use rustango::sql::FetcherPool as _;
use serde::Deserialize;
use crate::page::Page;
pub const DEFAULT_DEPTH: i64 = 3;
pub const MAX_DEPTH: i64 = 10;
pub const MAX_NODES: usize = 5_000;
#[derive(Debug, Default, Deserialize)]
pub struct TreeQuery {
#[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
pub root: Option<i64>,
#[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
pub depth: Option<i64>,
#[serde(default, deserialize_with = "crate::api::query::empty_string_as_none")]
pub locale: Option<String>,
}
pub async fn tree(
tenant: Tenant,
SessionUser(session_user): SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
Query(q): Query<TreeQuery>,
) -> Response {
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
match tree_inner(tenant.pool(), viewer, &q).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "page tree failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
pub async fn tree_inner(
pool: &rustango::sql::Pool,
viewer: Option<&rustango::tenancy::auth::User>,
q: &TreeQuery,
) -> Result<Response, rustango::sql::ExecError> {
let depth = q.depth.unwrap_or(DEFAULT_DEPTH).clamp(1, MAX_DEPTH);
let statuses = [
crate::page::PageStatus::Published.as_str().to_owned(),
crate::page::PageStatus::Archived.as_str().to_owned(),
];
let mut rows: Vec<Page> = Page::objects()
.where_(Page::status.is_in(statuses))
.order_by(&[("path", false)])
.fetch(pool)
.await?;
rows.sort_by_key(|p| (p.sort_order, p.id.get().copied().unwrap_or_default()));
let error_tid = crate::error_pages::error_page_type_id(pool).await;
rows.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
rows.retain(|p| p.locale_variant_of.is_none());
let triples: Vec<(i64, String, i64)> = rows
.iter()
.map(|p| {
(
p.id.get().copied().unwrap_or_default(),
p.path.clone(),
p.page_type_id,
)
})
.collect();
let denied = crate::view_restriction::denied_page_ids(pool, viewer, &triples).await;
if !denied.is_empty() {
rows.retain(|p| !denied.contains(&p.id.get().copied().unwrap_or_default()));
}
let root_parent = match q.root {
Some(root_id) => {
let Some(root) = rows
.iter()
.find(|p| p.id.get().copied() == Some(root_id))
.cloned()
else {
return Ok(
crate::api::error::ApiError::not_found("page").into_response()
);
};
let prefix = root.path.clone();
rows.retain(|p| p.path.starts_with(&prefix) && p.path != prefix);
Some(root_id)
}
None => None,
};
let alias_sources: Vec<i64> = rows.iter().filter_map(|p| p.alias_of).collect();
let alias_titles: std::collections::HashMap<i64, String> = if alias_sources.is_empty() {
std::collections::HashMap::new()
} else {
let sources: Vec<Page> = Page::objects()
.where_(Page::id.is_in(alias_sources))
.fetch(pool)
.await?;
let src_triples: Vec<(i64, String, i64)> = sources
.iter()
.map(|p| {
(
p.id.get().copied().unwrap_or_default(),
p.path.clone(),
p.page_type_id,
)
})
.collect();
let src_denied =
crate::view_restriction::denied_page_ids(pool, viewer, &src_triples).await;
sources
.into_iter()
.filter(|p| {
p.status == crate::page::PageStatus::Published.as_str()
|| p.status == crate::page::PageStatus::Archived.as_str()
})
.filter_map(|p| p.id.get().copied().map(|id| (id, p.title)))
.filter(|(id, _)| !src_denied.contains(id))
.collect()
};
let type_names = crate::api::pages::page_type_names(pool).await?;
let locale = crate::translation::resolve_locale(pool, q.locale.as_deref()).await?;
let translations = match locale.as_ref().filter(|l| !l.is_default) {
Some(l) => {
let lid = l.id.get().copied().unwrap_or_default();
let ids: Vec<i64> = rows
.iter()
.filter_map(|p| p.id.get().copied())
.chain(alias_titles.keys().copied())
.collect();
crate::translation::fetch_for_pages(pool, &ids, lid)
.await
.unwrap_or_default()
}
_ => std::collections::HashMap::new(),
};
let mut child_count: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
for p in &rows {
if let Some(pid) = p.parent_id {
*child_count.entry(pid).or_default() += 1;
}
}
let by_parent = crate::tree_build::index_by_parent(&rows, |p| {
if p.parent_id == root_parent {
None
} else {
p.parent_id
}
});
let emitted = std::cell::Cell::new(0usize);
let nodes = crate::tree_build::build(
&by_parent,
None,
depth,
&|p: &Page| p.id.get().copied().unwrap_or_default(),
&|p: &Page, children: Vec<serde_json::Value>| {
emitted.set(emitted.get() + 1);
node_json(
p,
children,
&alias_titles,
&translations,
&child_count,
&type_names,
)
},
);
let emitted = emitted.get();
let truncated = emitted > MAX_NODES;
let mut nodes = nodes;
if truncated {
let mut budget = MAX_NODES;
prune(&mut nodes, &mut budget);
}
Ok(Json(serde_json::json!({
"meta": {
"depth": depth,
"root": q.root,
"locale": locale.as_ref().map(|l| l.code.clone()),
"total_count": emitted.min(MAX_NODES),
"truncated": truncated,
"dropped_count": emitted.saturating_sub(MAX_NODES),
},
"items": nodes,
}))
.into_response())
}
fn prune(nodes: &mut Vec<serde_json::Value>, budget: &mut usize) {
let keep = nodes.len().min(*budget);
nodes.truncate(keep);
*budget -= keep;
for n in nodes.iter_mut() {
let Some(children) = n.get_mut("children").and_then(|c| c.as_array_mut()) else {
continue;
};
prune(children, budget);
}
}
fn node_json(
p: &Page,
children: Vec<serde_json::Value>,
alias_titles: &std::collections::HashMap<i64, String>,
translations: &std::collections::HashMap<i64, std::collections::HashMap<String, String>>,
child_count: &std::collections::HashMap<i64, usize>,
type_names: &std::collections::HashMap<i64, String>,
) -> serde_json::Value {
let id = p.id.get().copied().unwrap_or_default();
let source_id = p.alias_of.unwrap_or(id);
let base_title = p
.alias_of
.and_then(|src| alias_titles.get(&src).cloned())
.unwrap_or_else(|| p.title.clone());
let title = translations
.get(&source_id)
.and_then(|m| m.get("title"))
.filter(|s| !s.is_empty())
.cloned()
.unwrap_or(base_title);
let mut obj = serde_json::json!({
"id": id,
"title": title,
"type": type_names.get(&p.page_type_id).cloned().unwrap_or_default(),
"slug": p.slug,
"url": if p.url_path.is_empty() { "/" } else { p.url_path.as_str() },
"depth": p.depth,
"has_children": child_count.get(&id).copied().unwrap_or(0) > 0,
"detail_url": format!("/api/v2/pages/{id}/"),
"children": children,
});
if let Some(src) = p.alias_of {
obj["alias_of"] = serde_json::json!(src);
}
obj
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn sample() -> Vec<serde_json::Value> {
vec![
json!({"id": 1, "children": [
{"id": 2, "children": []},
{"id": 3, "children": []},
]}),
json!({"id": 4, "children": []}),
]
}
fn ids(nodes: &[serde_json::Value]) -> Vec<i64> {
let mut out = Vec::new();
for n in nodes {
out.push(n["id"].as_i64().unwrap());
out.extend(ids(n["children"].as_array().unwrap()));
}
out
}
#[test]
fn prune_counts_descendants_not_just_roots() {
let mut nodes = sample();
let mut budget = 3;
prune(&mut nodes, &mut budget);
assert_eq!(ids(&nodes).len(), 3);
}
#[test]
fn prune_keeps_a_breadth_then_depth_prefix() {
let mut nodes = sample();
let mut budget = 3;
prune(&mut nodes, &mut budget);
assert_eq!(ids(&nodes), vec![1, 2, 4]);
}
#[test]
fn prune_under_budget_changes_nothing() {
let mut nodes = sample();
let mut budget = MAX_NODES;
prune(&mut nodes, &mut budget);
assert_eq!(ids(&nodes), vec![1, 2, 3, 4]);
}
#[test]
fn a_zero_budget_empties_the_tree() {
let mut nodes = sample();
let mut budget = 0;
prune(&mut nodes, &mut budget);
assert!(nodes.is_empty());
}
#[test]
fn depth_is_clamped_to_the_ceiling() {
for (asked, want) in [(None, DEFAULT_DEPTH), (Some(999), MAX_DEPTH), (Some(0), 1)] {
let got = asked.unwrap_or(DEFAULT_DEPTH).clamp(1, MAX_DEPTH);
assert_eq!(got, want, "depth={asked:?}");
}
}
}