Skip to main content

rustango_cms/
page_tag.rs

1//! Page tag system.
2//!
3//! Tags are how editors organize blog-style content. Each \`PageTag\`
4//! row is a (page_id, name) pair; tag names are tenant-global
5//! strings (lowercased + trimmed on insert).
6//!
7//! Editor UI: a multi-select on the Promote tab with autocomplete
8//! from existing tags. List + API filter chips lookup by tag.
9
10use chrono::{DateTime, Utc};
11use rustango::sql::Auto;
12use rustango::Model;
13use serde::{Deserialize, Serialize};
14
15#[derive(Model, Debug, Clone, Serialize, Deserialize)]
16#[rustango(
17    table = "cms_page_tag",
18    app = "cms",
19    display = "name",
20    admin(
21        list_display = "page_id, name",
22        ordering = "name, page_id",
23        list_filter = "name",
24    )
25)]
26pub struct PageTag {
27    #[rustango(primary_key)]
28    pub id: Auto<i64>,
29
30    #[rustango(fk = "cms_page", on = "id", index)]
31    pub page_id: i64,
32
33    /// Tag name, lowercased + trimmed. Per-page-unique enforced at
34    /// the application layer (composite unique on the SQL side is
35    /// dialect-drifty in our ORM today).
36    #[rustango(max_length = 64, index)]
37    pub name: String,
38
39    #[rustango(auto_now_add)]
40    pub created_at: Auto<DateTime<Utc>>,
41}
42
43/// Normalize a tag name: trim + lowercase + collapse internal
44/// whitespace to single dashes (so \"Hello World\" → \"hello-world\").
45#[must_use]
46pub fn normalize_name(raw: &str) -> String {
47    raw.split_whitespace()
48        .collect::<Vec<_>>()
49        .join("-")
50        .to_lowercase()
51}
52
53/// Every tag for a page, in alphabetical order.
54///
55/// # Errors
56/// Driver / query failures.
57pub async fn tags_for_page(
58    pool: &rustango::sql::Pool,
59    page_id: i64,
60) -> Result<Vec<PageTag>, rustango::sql::ExecError> {
61    use rustango::core::Column as _;
62    use rustango::sql::FetcherPool as _;
63    PageTag::objects()
64        .where_(PageTag::page_id.eq(page_id))
65        .order_by(&[("name", false)])
66        .fetch(pool)
67        .await
68}
69
70/// Replace the tag set for a page. Idempotent — repeats produce no
71/// duplicate rows. Tag names are normalized via [`normalize_name`].
72///
73/// # Errors
74/// Driver / query failures.
75pub async fn replace_tags(
76    pool: &rustango::sql::Pool,
77    page_id: i64,
78    names: &[String],
79) -> Result<(), rustango::sql::ExecError> {
80    use rustango::core::Column as _;
81    use rustango::sql::FetcherPool as _;
82    let existing: Vec<PageTag> = PageTag::objects()
83        .where_(PageTag::page_id.eq(page_id))
84        .fetch(pool)
85        .await?;
86    for row in existing {
87        row.delete_pool(pool).await?;
88    }
89    let mut seen = std::collections::HashSet::new();
90    for n in names {
91        let norm = normalize_name(n);
92        if norm.is_empty() || !seen.insert(norm.clone()) {
93            continue;
94        }
95        let mut row = PageTag {
96            id: Auto::Unset,
97            page_id,
98            name: norm,
99            created_at: Auto::Unset,
100        };
101        row.insert_pool(pool).await?;
102    }
103    Ok(())
104}
105
106/// Pre-fetch every tag attached to any page in `page_ids`, grouped
107/// by `page_id`. Single `IN (…)` query instead of N point
108/// lookups so the public-render handler can join tags onto every
109/// `children` ctx entry without an N+1.
110///
111/// Tags within each bucket arrive in `name` ascending order so
112/// templates iterate predictably.
113///
114/// # Errors
115/// Driver / query failures.
116pub async fn prefetch_for_pages(
117    pool: &rustango::sql::Pool,
118    page_ids: &[i64],
119) -> Result<std::collections::HashMap<i64, Vec<PageTag>>, rustango::sql::ExecError> {
120    use rustango::core::Column as _;
121    use rustango::sql::FetcherPool as _;
122    if page_ids.is_empty() {
123        return Ok(std::collections::HashMap::new());
124    }
125    let rows: Vec<PageTag> = PageTag::objects()
126        .where_(PageTag::page_id.is_in(page_ids.iter().copied()))
127        .order_by(&[("name", false)])
128        .fetch(pool)
129        .await?;
130    let mut by_page: std::collections::HashMap<i64, Vec<PageTag>> =
131        std::collections::HashMap::new();
132    for row in rows {
133        by_page.entry(row.page_id).or_default().push(row);
134    }
135    Ok(by_page)
136}
137
138/// Every page id tagged with `name`.
139///
140/// # Errors
141/// Driver / query failures.
142pub async fn pages_with_tag(
143    pool: &rustango::sql::Pool,
144    name: &str,
145) -> Result<Vec<i64>, rustango::sql::ExecError> {
146    use rustango::core::Column as _;
147    use rustango::sql::FetcherPool as _;
148    let norm = normalize_name(name);
149    let rows: Vec<PageTag> = PageTag::objects()
150        .where_(PageTag::name.eq(norm))
151        .fetch(pool)
152        .await?;
153    Ok(rows.into_iter().map(|r| r.page_id).collect())
154}
155
156/// Every distinct tag in the tenant + its usage count, sorted by
157/// (-count, name).
158///
159/// # Errors
160/// Driver / query failures.
161pub async fn all_tags(
162    pool: &rustango::sql::Pool,
163) -> Result<Vec<(String, usize)>, rustango::sql::ExecError> {
164    use rustango::sql::FetcherPool as _;
165    let rows: Vec<PageTag> = PageTag::objects().fetch(pool).await?;
166    let mut counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
167    for row in rows {
168        *counts.entry(row.name).or_default() += 1;
169    }
170    let mut out: Vec<(String, usize)> = counts.into_iter().collect();
171    out.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
172    Ok(out)
173}
174
175#[cfg(test)]
176mod tests {
177    use super::*;
178
179    #[test]
180    fn normalize_lowercases() {
181        assert_eq!(normalize_name("Hello"), "hello");
182    }
183
184    #[test]
185    fn normalize_collapses_whitespace_to_dash() {
186        assert_eq!(normalize_name("  Hello   World "), "hello-world");
187    }
188
189    #[test]
190    fn normalize_empty_stays_empty() {
191        assert_eq!(normalize_name("   "), "");
192    }
193
194    #[test]
195    fn normalize_idempotent() {
196        let once = normalize_name("Foo Bar");
197        let twice = normalize_name(&once);
198        assert_eq!(once, twice);
199    }
200}