Skip to main content

rustango_cms/starter/
errors.rs

1//! A theme's error pages: what visitors see on a missing page (404), a
2//! refused one (403), a server failure (500) or maintenance (503).
3//!
4//! Each `error_pages` entry of `theme.json` becomes a published page of
5//! the built-in Error page type ([`crate::error_pages`]) under the home
6//! page, hidden from menus and search engines. The theme's
7//! `error_page.html` template renders it inside the site's own layout,
8//! so a missing URL keeps the header, footer and colours.
9
10use rustango::core::Column as _;
11use rustango::sql::{Auto, FetcherPool as _, Pool};
12use serde::Deserialize;
13use serde_json::{json, Value};
14
15use super::{with_block_ids, StarterError, UI_APP_LABEL};
16use crate::error_pages::{self as ep, ErrorPageExt};
17use crate::page::{Page, PageStatus};
18use crate::page_type_model::PageType;
19use crate::tree_ops::{NewPage, TreeError};
20
21/// One `error_pages` entry.
22#[derive(Debug, Deserialize)]
23#[serde(deny_unknown_fields)]
24pub struct ErrorPageSeed {
25    /// 404, 403, 500 or 503.
26    pub status: u16,
27    pub title: String,
28    /// Empty: `error-<status>`.
29    #[serde(default)]
30    pub slug: String,
31    /// Content blocks (`heading`, `paragraph`, `quote`, …), as a list of
32    /// `{ "type": …, "value": { … } }` entries.
33    #[serde(default)]
34    pub body: Value,
35}
36
37impl ErrorPageSeed {
38    fn slug(&self) -> String {
39        if self.slug.is_empty() {
40            format!("error-{}", self.status)
41        } else {
42            self.slug.clone()
43        }
44    }
45}
46
47/// What is wrong with the entries, checked before anything is written.
48/// `home_slugs` are the slugs of the pages the theme puts under its home
49/// page, which an error page's slug must not repeat.
50pub(super) fn problems(seeds: &[ErrorPageSeed], home_slugs: &[&str]) -> Vec<String> {
51    let mut problems = Vec::new();
52    let mut seen = Vec::new();
53    for seed in seeds {
54        let status = seed.status;
55        if !ep::STATUSES.contains(&status) {
56            problems.push(format!("error page {status}: status must be one of 404, 403, 500, 503"));
57        }
58        if seen.contains(&status) {
59            problems.push(format!("error page {status} is listed twice"));
60        }
61        seen.push(status);
62        if home_slugs.contains(&seed.slug().as_str()) {
63            problems.push(format!("error page {status}: slug `{}` is taken by another page", seed.slug()));
64        }
65        match &seed.body {
66            Value::Null => {}
67            Value::Array(entries) => {
68                for entry in entries {
69                    let kind = entry["type"].as_str().unwrap_or_default();
70                    if !ep::BODY_BLOCKS.contains(&kind) {
71                        problems.push(format!(
72                            "error page {status}: block `{kind}` is not allowed (use {})",
73                            ep::BODY_BLOCKS.join(", ")
74                        ));
75                    }
76                }
77            }
78            _ => problems.push(format!("error page {status}: `body` must be a list of blocks")),
79        }
80    }
81    problems
82}
83
84/// Create the error pages under `home`, published. Returns how many.
85pub(super) async fn create(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed]) -> Result<usize, StarterError> {
86    add(pool, home, seeds, false).await
87}
88
89/// Create the error pages a site lacks: a status that already has a
90/// published error page, or a slug already used under `home`, is skipped,
91/// so an editor's own pages stay. A home page whose type (defined in code)
92/// refuses error pages gets none. Returns how many were added.
93pub(super) async fn add_missing(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed]) -> Result<usize, StarterError> {
94    add(pool, home, seeds, true).await
95}
96
97async fn add(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed], only_missing: bool) -> Result<usize, StarterError> {
98    if seeds.is_empty() {
99        return Ok(0);
100    }
101    let type_id = error_page_type(pool).await?;
102    allow_under(pool, home.page_type_id).await?;
103    let home_id = *home.id.get().ok_or(TreeError::MissingId)?;
104    let mut added = 0;
105    for seed in seeds {
106        let slug = seed.slug();
107        if only_missing {
108            let slug_taken = Page::objects()
109                .where_(Page::parent_id.eq(home_id))
110                .where_(Page::slug.eq(slug.clone()))
111                .first(pool)
112                .await?
113                .is_some();
114            if slug_taken || ep::find_for_status(pool, seed.status).await?.is_some() {
115                continue;
116            }
117        }
118        let new = NewPage::new(type_id, &seed.title, &slug).with_status(PageStatus::Published);
119        let mut page = match Page::create_child_pool(pool, home, new).await {
120            Ok(page) => page,
121            Err(TreeError::DisallowedChildType { .. } | TreeError::DisallowedParentType { .. }) if only_missing => {
122                return Ok(added);
123            }
124            Err(e) => return Err(e.into()),
125        };
126        page.robots_index = false;
127        page.show_in_menus = false;
128        page.save(pool).await?;
129        let page_id = *page.id.get().ok_or(TreeError::MissingId)?;
130        let body = match &seed.body {
131            Value::Null => None,
132            body => {
133                let keyed = with_block_ids(&json!({ "body": body }), &format!("error-{}", seed.status));
134                Some(keyed["body"].to_string())
135            }
136        };
137        let mut row = ErrorPageExt {
138            id: Auto::Unset,
139            page_id,
140            status_code: seed.status.to_string(),
141            body,
142        };
143        row.insert(pool).await?;
144        crate::revision::capture(pool, &page, None).await?;
145        added += 1;
146    }
147    Ok(added)
148}
149
150/// The site's Error page type row, registered first when the site was
151/// never seeded (a seeder normally runs after the code types are).
152async fn error_page_type(pool: &Pool) -> Result<i64, StarterError> {
153    if let Some(id) = ep::error_page_type_id(pool).await {
154        return Ok(id);
155    }
156    let handler = crate::page_type::find_handler(ep::TYPE_NAME)
157        .ok_or_else(|| StarterError::Invalid("the Error page type is not registered".into()))?;
158    crate::seed::upsert_page_type(pool, handler.as_ref()).await?;
159    ep::error_page_type_id(pool)
160        .await
161        .ok_or_else(|| StarterError::Invalid("the Error page type could not be set up".into()))
162}
163
164/// Let a theme-made home type hold error pages when it names the child
165/// types it accepts. (An empty list already accepts any type.)
166async fn allow_under(pool: &Pool, type_id: i64) -> Result<(), StarterError> {
167    let Some(mut row) = PageType::objects().where_(PageType::id.eq(type_id)).first(pool).await? else {
168        return Ok(());
169    };
170    let mut children = row.allowed_children();
171    if row.app_label != UI_APP_LABEL || children.is_empty() || children.iter().any(|t| t == ep::TYPE_NAME) {
172        return Ok(());
173    }
174    children.push(ep::TYPE_NAME.to_owned());
175    row.allowed_child_types = json!(children);
176    row.save(pool).await?;
177    Ok(())
178}
179
180/// The site's error pages under `home`, as `error_pages` entries for a
181/// package. Image blocks are left out: the pictures they point at exist
182/// only on this site.
183pub(super) async fn export(pool: &Pool, home: &Page) -> Result<Vec<Value>, StarterError> {
184    let Some(type_id) = ep::error_page_type_id(pool).await else {
185        return Ok(Vec::new());
186    };
187    let Some(home_id) = home.id.get().copied() else {
188        return Ok(Vec::new());
189    };
190    let pages: Vec<Page> = Page::objects()
191        .where_(Page::parent_id.eq(home_id))
192        .where_(Page::page_type_id.eq(type_id))
193        .order_by(&[("sort_order", false), ("id", false)])
194        .fetch(pool)
195        .await?;
196    let mut out: Vec<Value> = Vec::new();
197    for page in pages {
198        let Some(page_id) = page.id.get().copied() else { continue };
199        let Some(ext) = ErrorPageExt::objects()
200            .where_(ErrorPageExt::page_id.eq(page_id))
201            .first(pool)
202            .await?
203        else {
204            continue;
205        };
206        let Ok(status) = ext.status_code.parse::<u16>() else { continue };
207        if out.iter().any(|e| e["status"] == json!(status)) {
208            continue;
209        }
210        let mut blocks: Vec<Value> = ext
211            .body
212            .as_deref()
213            .and_then(|b| serde_json::from_str::<Value>(b).ok())
214            .and_then(|b| b.as_array().cloned())
215            .unwrap_or_default();
216        blocks.retain(|b| b["type"] != "image");
217        for b in &mut blocks {
218            if let Value::Object(fields) = b {
219                fields.remove("id");
220            }
221        }
222        out.push(json!({ "status": status, "title": page.title, "slug": page.slug, "body": blocks }));
223    }
224    Ok(out)
225}
226
227#[cfg(test)]
228mod tests {
229    use super::*;
230
231    fn seed(status: u16, slug: &str, body: Value) -> ErrorPageSeed {
232        ErrorPageSeed { status, title: "T".into(), slug: slug.into(), body }
233    }
234
235    #[test]
236    fn entries_are_checked_before_anything_is_written() {
237        let ok = [
238            seed(404, "", json!([{ "type": "paragraph", "value": { "body": "x" } }])),
239            seed(500, "oops", Value::Null),
240        ];
241        assert!(problems(&ok, &["about"]).is_empty());
242
243        let bad = [
244            seed(418, "", Value::Null),
245            seed(404, "about", json!([{ "type": "gallery", "value": {} }])),
246            seed(404, "", json!("text")),
247        ];
248        let found = problems(&bad, &["about"]).join("; ");
249        for expected in [
250            "status must be one of",
251            "slug `about` is taken",
252            "block `gallery` is not allowed",
253            "listed twice",
254            "must be a list of blocks",
255        ] {
256            assert!(found.contains(expected), "{expected}: {found}");
257        }
258    }
259
260    #[test]
261    fn the_slug_defaults_to_the_status() {
262        assert_eq!(seed(503, "", Value::Null).slug(), "error-503");
263        assert_eq!(seed(404, "page-not-found", Value::Null).slug(), "page-not-found");
264    }
265}