Rustango docs
← Guides

Vues HTML — pages rendues côté serveur

Une vue HTML transforme un modèle en pages web rendues côté serveur — une page de liste, une page de détail, et des formulaires de création/édition/suppression — à partir d'une seule déclaration. C'est le pendant des ViewSets : là où un ViewSet émet du JSON pour des clients d'API, une vue HTML émet une page rendue pour un navigateur. Les deux sont construits à partir du même #[derive(Model)], et vous pouvez servir un modèle des deux façons à la fois.

Chaque type de vue (ListView, DetailView, CreateView, UpdateView, DeleteView) couvre un cas standard et effectue son rendu via des templates Tera.

Les vues HTML dans Rustango : un modèle alimente ListView, DetailView et CreateView/UpdateView/DeleteView, chacune effectuant le rendu d'un template Tera en une page rendue côté serveur

Un terme vous est inconnu ? Si modèle, template, routeur ou rendu côté serveur ne vous sont pas familiers, le glossaire explique chacun d'eux en langage simple.

Source : rustango::template_views (ListView, DetailView, CreateView, UpdateView, DeleteView, TemplateView, RedirectView) — derrière la fonctionnalité template_views (activée par défaut).

Version exécutable : l'exemple API-vs-HTML ci-dessous est fixé par le test du framework html_and_api_contrast_sqlite_live.rs (cargo test -p rustango --features sqlite --test html_and_api_contrast_sqlite_live). Les vues individuelles sont couvertes par template_view.rs et template_views_context_object_name_sqlite_live.rs.

Table des matières


Vues API vs vues HTML — laquelle vous faut-il ?

C'est la première décision. Les deux transforment un modèle en points d'accès ; elles diffèrent par ce qui en ressort et qui appelle.

Vue API — ViewSetVue HTML — ce guide
Modulerustango::viewsetrustango::template_views
Renvoiedes données JSONune page HTML rendue côté serveur
Conçue pourSPA, applications mobiles, autres servicesnavigateurs, sites rendus côté serveur, CRUD façon admin
Une « création »POST JSON → 201 + le nouvel objetPOST d'un formulaire → redirection 303 vers une page de succès
En cas d'entrée invalide422 + une carte d'erreurs JSON indexée par champre-rend le formulaire avec les erreurs affichées
Lit une liste commeune enveloppe JSON paginéeun <table>/une boucle dans votre template
Authentifiée en général parjetons / JWT / clés d'APIcookies de session

Vous n'avez pas à choisir globalement — choisissez par ressource, et vous pouvez monter les deux sur le même modèle (voir ci-dessous). Règles empiriques :

  • Vous construisez un backend JSON pour un framework frontend ou une application mobile → ViewSet.
  • Vous construisez un site rendu côté serveur (le serveur renvoie des pages HTML) → vues HTML.
  • Vous avez besoin des deux (une API publique et des pages CRUD internes) → montez les deux.

Vous cherchez le côté JSON ? Il a son propre approfondissement : ViewSets — API REST CRUD.


Les cinq vues de modèle

Chaque vue est for_model(SCHEMA) plus un .router(prefix, tera, pool). Les monter au même prefix (disons /posts) donne l'ensemble d'URL CRUD classique :

VueRendRoutes montéesTemplate par défaut
ListViewune liste paginéeGET <prefix><table>_list.html
DetailViewune ligneGET <prefix>/{pk}<table>_detail.html
CreateViewun formulaire de nouvel enregistrementGET/POST <prefix>/new<table>_form.html
UpdateViewun formulaire d'édition prérempliGET/POST <prefix>/{pk}/edit<table>_form.html
DeleteViewune page de confirmationGET/POST <prefix>/{pk}/delete<table>_confirm_delete.html

<table> est le nom de la table du modèle, donc un Post (table posts) recherche posts_list.html, posts_detail.html, et ainsi de suite. Remplacez n'importe lequel d'entre eux avec .template("my_name.html").

Qui peut utiliser une vue

Une vue de modèle refuse de se monter tant que vous n'avez pas dit qui peut l'utiliser ; aucune page ne part ouverte par accident. Appelez l'une de ces méthodes sur chaque vue :

AppelQui entre
.allow_anonymous()quiconque atteint le routeur ; placez votre propre couche d'auth devant si besoin (exemple)
.login_required()tout utilisateur connecté ; les autres reçoivent 401
.permissions(&["posts.change"])un utilisateur connecté qui a chaque codename ; les superutilisateurs passent
.permissions_for_model()le codename du modèle : view pour List et Detail, add, change, delete pour les vues d'écriture

Les trois dernières demandent la feature tenancy et vont sur .tenant_router(..) : l'utilisateur y vient de require_auth / optional_auth ou du cookie de session et doit appartenir à ce tenant. Sur un .router(prefix, tera, pool) à pool fixe, seul compte un utilisateur posé par votre propre couche d'auth mono-base ; l'utilisateur d'un tenant reçoit 403. Avec permissions_for_model(), un ListView avec .bulk_actions(true) demande view, change et delete pour son POST. Pour envoyer les visiteurs anonymes vers une page de connexion plutôt qu'un 401, entourez le routeur de auth_decorators::login_required("/login").

Les vues appliquent les mêmes règles de ligne qu'un ViewSet : les scopes register_queryset_scope! restreignent chaque lecture et écriture, et le hook view masque des lignes (404 sur les pages de détail, d'édition et de suppression ; absentes des listes, des actions groupées et des noms d'affichage des FK). Les hooks change et delete refusent avec un 403, et un delete_selected qui contient une ligne refusée donne un 403 en entier. Un formulaire ne peut pas pointer une FK vers une ligne que les scopes ou le hook view de la cible masquent (erreur de formulaire). Une liste parcourt au plus view_hook_scan_cap lignes (2 000 par défaut) pour le hook view ; au-delà, la page donne un 400.


ListView

Une page de liste paginée. Vous fournissez un template qui boucle sur object_list ; la vue gère la pagination, le tri, le filtrage et la recherche à partir des paramètres de requête.

use rustango::template_views::ListView;
use std::sync::Arc;

// Escapes every template, not only `.html` ones.
let tera = rustango::template_extensions::html_tera_from_glob("templates/**/*")?;
let app = ListView::for_model(Post::SCHEMA)
    .page_size(20)                       // rows per page (?page=N to navigate)
    .order_by("published_at", true)      // default sort, true = DESC
    .filter_fields(&["status", "author_id"])  // ?status=published
    .search_fields(&["title", "body"])        // ?search=rust
    .allow_anonymous()                        // a public page
    .router("/posts", Arc::new(tera), pool);

Un posts_list.html correspondant — notez object_list et les variables de pagination que la vue estampille pour vous :

<h1>Posts ({{ total }})</h1>
{% for post in object_list %}
  <article>
    <h2><a href="/posts/{{ post.id }}">{{ post.title }}</a></h2>
    <p>{{ post.body }}</p>
  </article>
{% endfor %}

{% if has_prev %}<a href="?page={{ page - 1 }}">← prev</a>{% endif %}
page {{ page }} / {{ total_pages }}
{% if has_next %}<a href="?page={{ page + 1 }}">next →</a>{% endif %}

?page=, ?status= et ?search= fonctionnent de la même façon que sur une liste ViewSet — la différence tient uniquement au fait que le résultat est une page rendue plutôt qu'une enveloppe JSON. Utilisez .context_object_name("posts") si vous préférez boucler sur posts plutôt que sur object_list dans le template.

La taille de page vaut 20 par défaut. Un client peut demander ?page_size=N, plafonné par .max_page_size(n) (100 par défaut) ; une page au-delà de la ligne .max_offset(n) (10 000 par défaut, 0 lève la limite) répond 400. .bulk_actions(true) fait accepter à la liste un POST avec un champ action et les pk choisies : delete_selected est intégrée, .action(...) ajoute les vôtres, et .with_delete_confirmation(true) affiche d'abord une page de confirmation. .with_fk_display(true) ajoute une valeur <column>_display pour chaque clé étrangère, au prix d'une requête de plus par colonne FK et par page.

?ordering= est l'exception. La liste blanche d'un ListView démarre vide, donc le paramètre est ignoré tant que vous ne nommez pas vous-même les colonnes triables :

fn post_list() -> ListView {
    ListView::for_model(Post::SCHEMA)
        .allow_anonymous()
        .ordering_fields(&["title", "published_at"])
}

Sans cet appel, la liste retombe sur le .order_by(...) du builder, ou sur PK-ASC pour que la pagination reste déterministe. Une seule colonne est acceptée, avec un - initial pour l'ordre décroissant.


DetailView

Une ligne, recherchée à partir de l'URL. Par défaut elle correspond à la clé primaire (/posts/42) ; pointez-la vers une autre colonne avec .lookup_field("slug") pour des URL jolies (/posts/my-first-post). Une ligne manquante est un 404.

use rustango::template_views::DetailView;

let app = DetailView::for_model(Post::SCHEMA)
    .lookup_field("slug")          // GET /posts/{slug} instead of /posts/{id}
    .allow_anonymous()
    .router("/posts", Arc::new(tera), pool);

Le template reçoit la ligne sous le nom object :

<h1>{{ object.title }}</h1>
<p>{{ object.body }}</p>
<small>by author #{{ object.author_id }}</small>

CreateView, UpdateView, DeleteView

Le côté écriture. Chacune gère un GET (rendre un formulaire / une page de confirmation) et un POST (faire le travail, puis rediriger). La redirection-après-POST est le motif standard Post/Redirect/Get — il empêche qu'un rafraîchissement du navigateur ne re-soumette.

CreateView — GET /posts/new rend un formulaire vide ; POST /posts/new insère la ligne et fait un 303 vers success_url :

use rustango::template_views::CreateView;

let app = CreateView::for_model(Post::SCHEMA, &["title", "body", "author_id"])
    .success_url("/posts")         // where to send the browser after a save
    .permissions_for_model()       // `posts.add`
    .tenant_router("/posts", Arc::new(tera));

La liste des champs est obligatoire. C'est la liste blanche d'écriture : le formulaire n'affiche que ces champs et toute autre clé envoyée (par exemple id=1) est ignorée. Avec UpdateView, un champ listé mais absent garde sa valeur ; seul un bool passe à false, car une case décochée n'envoie rien. Avec CreateView, un champ listé absent qui a un défaut de colonne reçoit ce défaut.

Chaque champ listé est une saisie de l'utilisateur. Ici le navigateur envoie author_id, donc n'importe qui peut publier au nom d'un autre. CreateView ne sait pas encore fixer un champ côté serveur : pour un champ que le serveur décide (l'auteur connecté), écrivez votre propre handler.

Le template de formulaire (posts_form.html) est partagé avec UpdateView. is_update distingue les deux, et form porte à la fois les champs et les éventuels messages de validation :

<form method="post">
  {{ csrf_input | safe }}
  {% if form.errors.__all__ %}<p class="error">{{ form.errors.__all__ }}</p>{% endif %}
  {% for field in form.fields %}
    <label for="{{ field.name }}">{{ field.name }}</label>
    <input id="{{ field.name }}" name="{{ field.name }}" value="{{ field.value }}"
           {% if field.required %}required{% endif %}
           {% if field.max_length %}maxlength="{{ field.max_length }}"{% endif %}>
    {% if form.errors[field.name] %}
      <p class="error">{{ form.errors[field.name] }}</p>
    {% endif %}
  {% endfor %}
  <button>{% if is_update %}Save{% else %}Create{% endif %}</button>
</form>

Une écriture que la base refuse (une colonne NOT NULL que le formulaire omet, un CHECK) est une erreur de tout le formulaire sous form.errors.__all__, pas sous un champ ; affichez-la, sinon la page revient sans message.

Deux choses sont faciles à se tromper ici. form.errors associe un nom de champ à une seule chaîne, pas à une liste — lui appliquer join est une erreur. Et il n'existe pas de variable errors de premier niveau ; en itérer une est un échec de rendu Tera, si bien que la page renvoie 500 au lieu d'afficher le message.

{{ csrf_input | safe }} a besoin du filtre : Tera échappe automatiquement les .html, donc sans lui le jeton est rendu comme du texte et chaque POST est rejeté.

Validation. Les règles de schéma (type, max_length, NOT NULL…) sont appliquées automatiquement. Ajoutez les vôtres avec un validateur en closure — en cas d'Err, le formulaire est re-rendu avec les messages et un statut 422 au lieu d'être enregistré :

use rustango::forms::FormErrors;

CreateView::for_model(Post::SCHEMA, &["title", "body", "author_id"])
    .validator(|data| {
        let mut errs = FormErrors::default();
        if data.get("title").map_or(true, |t| t.len() < 5) {
            errs.add("title", "must be at least 5 characters");
        }
        if errs.is_empty() { Ok(()) } else { Err(errs) }
    })
    .success_url("/posts")
    .permissions_for_model()
    .tenant_router("/posts", Arc::new(tera));

Vous pouvez aussi réutiliser les validateurs d'une structure #[derive(Form)] avec .form::<F>() (validation seulement pour l'instant — voir la documentation de l'API).

UpdateView — GET /posts/{pk}/edit rend le même formulaire prérempli à partir de la ligne (object est renseigné, is_update vaut true) ; POST met à jour et fait un 303.

use rustango::template_views::UpdateView;

UpdateView::for_model(Post::SCHEMA, &["title", "body"])
    .success_url("/posts")
    .permissions_for_model()       // `posts.change`
    .tenant_router("/posts", Arc::new(tera));

DeleteView — GET /posts/{pk}/delete rend une page de confirmation (posts_confirm_delete.html, avec object) ; POST supprime et fait un 303.

use rustango::template_views::DeleteView;

DeleteView::for_model(Post::SCHEMA)
    .success_url("/posts")
    .permissions_for_model()       // `posts.delete`
    .tenant_router("/posts", Arc::new(tera));

Montez les cinq au même préfixe et vous avez un CRUD HTML complet :

let app = axum::Router::new()
    .merge(ListView::for_model(Post::SCHEMA).allow_anonymous().tenant_router("/posts", tera.clone()))
    .merge(DetailView::for_model(Post::SCHEMA).allow_anonymous().tenant_router("/posts", tera.clone()))
    .merge(CreateView::for_model(Post::SCHEMA, &["title", "body", "author_id"]).permissions_for_model().success_url("/posts").tenant_router("/posts", tera.clone()))
    .merge(UpdateView::for_model(Post::SCHEMA, &["title", "body"]).permissions_for_model().success_url("/posts").tenant_router("/posts", tera.clone()))
    .merge(DeleteView::for_model(Post::SCHEMA).permissions_for_model().success_url("/posts").tenant_router("/posts", tera));

Le contexte Tera

Chaque vue estampille un contexte cohérent afin que les templates se portent proprement de l'une à l'autre :

VueVariables disponibles dans le template
ListViewobject_list (les lignes de la page), page, page_size, total, total_pages, has_next, has_prev, page_marks, prev_page_url / next_page_url, ordering, filters, search (and bulk_actions when on)
DetailViewobject (la ligne)
CreateViewform (.fields, .errors), is_create (true), is_update (false) — pas d'object
UpdateViewform (.fields, .errors), object (les champs listés, la clé primaire et les .context_fields()), pk, is_create (false), is_update (true)
DeleteViewobject (la ligne à confirmer)

Les lignes sont exposées sous forme de simples maps indexées par nom de colonne ({{ post.title }}), avec le NULL SQL rendu en null. Utilisez .context_object_name("posts" / "post") pour ajouter un alias plus convivial à côté de object_list / object.

Chaque entrée de form.fields porte name, column, ty, required, max_length et value. form.errors est indexé par nom de champ et contient un message par champ, pas une liste. Chaque vue estampille aussi csrf_token et csrf_input, et chaque routeur de vue rejette un POST sans jeton correspondant.

Une case à cocher et une chaîne blank ne sont jamais required, ni un champ avec default dans un formulaire de création : envoyé vide, il prend la valeur par défaut de la colonne.

CreateView n'estampille aucun object, donc {{ object.title }} dans un formulaire de création est indéfini plutôt que vide — utilisez {{ field.value }} depuis form.fields, qui est renseigné dans les deux cas.


TemplateView et RedirectView

Deux helpers sans modèle pour les pages que tout site possède :

TemplateView — rend un template statique avec un contexte fixe (une page « à propos », une page d'atterrissage). Pas de modèle, pas de base de données :

use rustango::template_views::TemplateView;

let app = TemplateView::new("about.html")
    .context_value("title", "About us")
    .router("/about", Arc::new(tera));

RedirectView — une redirection permanente ou temporaire sur une URL (pour les pages déplacées) :

use rustango::template_views::RedirectView;

let app = RedirectView::to("/posts").router("/old-posts");

Elle répond 302 Found ; .permanent() en fait un 301.

FormView — un formulaire sans modèle. FormView::<ContactForm>::for_form(handler) rend un formulaire #[derive(Form)] en GET (template form.html par défaut). En POST, il valide et appelle votre handler async ; Ok(()) redirige en 303, et Err(msg) ré-affiche le formulaire. Une saisie invalide le ré-affiche avec un 422. Son contexte est errors (une liste par champ ; les erreurs globales sous __all__) et values. Comme pour toutes les vues ici, .success_url vaut / par défaut.


Mono-locataire vs multi-locataire

Chaque vue de modèle est livrée avec deux constructeurs de routeur — même builder, choisissez celui qui correspond à la façon dont votre application gère les connexions à la base de données :

  • .router(prefix, tera, pool) — mono-locataire ; capture un pool unique au moment du montage. C'est ce qu'utilisent les exemples ci-dessus.
  • .tenant_router(prefix, tera) — multi-locataire ; résout une connexion par requête à partir de l'extracteur Tenant. Disponible avec les fonctionnalités template_views + tenancy. Les templates se portent inchangés de l'une à l'autre.

Cela reflète la séparation des ViewSets (router vs tenant_router).


Servir un modèle des deux façons

Vous n'êtes pas limité à une seule porte d'entrée. Montez une API JSON et des pages HTML sur le même modèle et le même pool — une API publique pour les clients, des pages rendues côté serveur pour les personnes :

use rustango::viewset::ViewSet;
use rustango::template_views::{ListView, DetailView};

let app = axum::Router::new()
    // JSON for API clients:
    .merge(ViewSet::for_model(Post::SCHEMA, &["id", "title", "body"]).read_only().router("/api/posts", pool.clone()))
    // HTML pages for browsers:
    .merge(ListView::for_model(Post::SCHEMA).allow_anonymous().router("/posts", tera.clone(), pool.clone()))
    .merge(DetailView::for_model(Post::SCHEMA).allow_anonymous().router("/posts", tera, pool));

Maintenant GET /api/posts renvoie l'enveloppe JSON paginée et GET /posts renvoie une liste HTML rendue — mêmes lignes, même pool, deux formes. Cette configuration exacte est ce qu'affirme le test de support.


Pages d'erreur

Un layer transforme chaque 4xx/5xx de votre app en page pour les humains et laisse les clients d'API tranquilles. Il est désactivé par défaut ; rien ne change tant que vous ne l'activez pas. Nécessite la feature template_views.

L'activer

Sur le serveur multi-locataire, le layer enveloppe tout : votre API, le login du locataire, l'admin du locataire, la console opérateur et les layers du framework.

use std::sync::Arc;
use rustango::errors::ErrorPagesLayer;

let tera = Arc::new(rustango::template_extensions::html_tera_from_glob("templates/**/*.html")?);
let app = rustango::server::Builder::from_env().await?
    .api(my_app::urls::api())
    .error_pages(ErrorPagesLayer::new().templates(tera));

AppBuilder::error_pages fait de même pour une app à pool unique. Sur votre propre routeur, montez-le avec ErrorPagesRouterExt et ajoutez le fallback 404 :

use rustango::errors::{ErrorPagesLayer, ErrorPagesRouterExt as _};

let app = Router::new()
    .route("/projects", get(projects))
    .fallback(rustango::errors::not_found)
    .error_pages(ErrorPagesLayer::new().templates(tera.clone()));

Avec Cli et un fichier de config, utilisez plutôt la section [errors] :

[errors]
enabled = true            # default false
templates = "templates"   # template root holding errors/404.html etc.; default "templates"
htmx_target = "#flash"    # HX-Retarget for htmx errors; default "#flash", "" sends none

Un répertoire templates absent est ignoré sans bruit ; un répertoire qui ne se parse pas est journalisé. Dans les deux cas, les pages intégrées sont utilisées.

cargo rustango new écrit [errors] enabled = true dans config/default.toml, donc un nouveau projet a les pages activées. Les projets plus anciens restent désactivés tant qu'ils n'ajoutent pas la section.

Ce que reçoit chaque client

RequêteRéponse
Navigation navigateur (Accept: text/html, sans HX-Request)Page HTML complète
htmx (HX-Request)Fragment HTML, plus HX-Retarget: <htmx_target> et HX-Reswap: innerHTML show:window:top
Tout autre client (fetch, curl)Corps inchangé ; un corps vide reçoit le message en texte brut
JSON / problem+jsonInchangé, sauf s'il porte un Message et qu'un navigateur ou htmx demande
HEADInchangé
Une réponse marquée rustango::errors::KeepBodyInchangée

Un corps d'erreur text/html est remplacé lui aussi, sauf si la réponse est marquée KeepBody : marquez toute page d'erreur HTML que vous construisez vous-même.

Seuls les corps texte (text/plain, text/html, aucun) et le JSON avec message sont remplacés ; images et autres types passent. Une réponse habillée garde son statut et ses en-têtes (Retry-After aussi) et reçoit Vary: Accept, HX-Request.

Templates

Le premier template présent dans votre Tera l'emporte :

  1. errors/<code>.html, p. ex. errors/404.html
  2. errors/4xx.html ou errors/5xx.html
  3. errors/default.html
  4. la page intégrée

Les fragments htmx utilisent errors/partial.html, puis le fragment intégré. Un template dont le rendu échoue est journalisé et la page intégrée est utilisée ; une page d'erreur ne revient jamais vide.

templates/errors/404.html :

{% extends "base.html" %}
{% block content %}
<section class="error">
  <h1>{{ code }} · {{ title }}</h1>
  <p>{{ message }}</p>
  <p>Nothing at <code>{{ path }}</code>.</p>
  {% if user %}<p>Signed in as {{ user.username }}.</p>{% endif %}
  <a href="/">Back to the start</a>
</section>
{% endblock content %}

templates/errors/5xx.html :

{% extends "base.html" %}
{% block content %}
<section class="error">
  <h1>{{ title }}</h1>
  <p>{{ message }}</p>
  <form method="post" action="/feedback">{{ csrf_input | safe }}
    <button>Tell us what you were doing</button>
  </form>
</section>
{% endblock content %}

Contexte :

CléValeur
codeLe statut, p. ex. 404
titleUn titre court par statut (« Not found »)
messageCe qui s'est mal passé, pour l'utilisateur (voir plus bas)
pathLe chemin de la requête
user{ username, is_superuser } de l'utilisateur connecté du locataire, ou null
username, is_superuserLa même chose, à plat
csrf_token, csrf_inputUn jeton CSRF et son input caché, sous le nom de cookie de votre layer CSRF. Le cookie n'est posé que si le template les utilise
csp_nonceLe nonce CSP de cette requête, ou ""
brand_name, brand_logo_url, brand_css, theme_modeDepuis [brand]

user nécessite la feature tenancy et un hôte de locataire ; ailleurs il vaut null. Les templates sont par app : chaque locataire reçoit les mêmes.

La page intégrée

HTML autonome : pas de CDN, pas de script, CSS inline avec le nonce CSP de la requête, les tokens de thème de l'admin (clair et sombre). Avec [errors] dans les settings, elle affiche [brand] name et logo_url ; primary_color et theme_mode fixent les couleurs (ils nécessitent la feature tenancy, dont elle réutilise le code de marque). ErrorPagesLayer::brand(&settings.brand) fait de même en code.

Le message

Un handler donne des mots à la page avec rustango::errors::Message, une extension de réponse, ou avec PageError, qui en porte un :

use rustango::errors::{Message, PageError};

async fn project(Path(slug): Path<String>) -> Result<Html<String>, PageError> {
    let project = find_project(&slug)
        .await
        .map_err(PageError::server)?            // logged; the page says something generic
        .ok_or_else(|| PageError::not_found("No project with that name."))?;
    Ok(Html(render_project(&project)))
}

async fn archived() -> impl IntoResponse {
    (StatusCode::GONE, Message::new("This project was archived."))
}

Sans Message, un corps 4xx text/plain de 2 Kio au plus est le message (les rejets d'axum, la vérification CSRF), sinon le texte par défaut du statut. La première lettre passe en majuscule.

Un 5xx ne montre jamais sa cause : la page utilise le texte générique, et PageError::server(e) journalise e et envoie le même corps opaque que tout autre 5xx. Ce n'est que lorsque RUSTANGO_DISCLOSE_ERRORS est défini qu'une page 5xx montre son message ou son corps — la même règle que pour tout corps 5xx du framework.

PageError::forbidden(msg) et PageError::new(status, msg) couvrent les autres statuts. ErrorPagesLayer::htmx_swap(..) change la valeur HX-Reswap.

Ce qui est couvert

Monté par Builder::error_pages (ou [errors]), le layer se place à l'intérieur des en-têtes de sécurité et à l'extérieur de tout le reste ; il habille donc :

  • les chemins et hôtes inconnus (404), et les 405 ;
  • le 500 du panic guard ;
  • le 403 du layer CSRF, avec sa raison ;
  • les gardes login_required_or_401 / *_or_403 (401, 403) ;
  • la limite de corps (413), le timeout de requête (504), le rate limit et le throttle de login (429) ;
  • les rejets d'axum (400, 415, 422) ;
  • les refus et 404 de l'admin du locataire, et les chemins inconnus de la console opérateur.

Les pages qui portent leurs propres contrôles gardent leur aspect : toute page d'erreur HTML de l'admin, de l'admin tenant, de la console opérateur et des vues génériques, comme un formulaire réaffiché avec son erreur, la page « admin access required » (elle a un formulaire de déconnexion) et la page « table not migrated ». Marquez vos propres réponses avec KeepBody pour faire de même.

Migrer depuis un middleware d'erreur écrit à la main

Une app qui avait son propre middleware error_pages peut supprimer :

  • le middleware (from_fn(error_pages)) et son .fallback(not_found) ;
  • sa table titres/messages : rustango::errors::error_words est la même table ;
  • son extension de message privée : renvoyez PageError ou Message ;
  • le clonage d'en-têtes/extensions qu'il faisait pour poser le CSRF et trouver l'utilisateur.

Gardez templates/error.html comme templates/errors/default.html et l'alerte htmx comme templates/errors/partial.html ; les clés du contexte sont les mêmes.


Voir aussi