Vistas HTML — páginas renderizadas en el servidor
Una vista HTML convierte un modelo en páginas web renderizadas en el servidor — una
página de listado, una página de detalle y formularios de creación/edición/borrado — a partir de
una sola declaración. Es la hermana de los ViewSets: donde un ViewSet emite JSON
para clientes de API, una vista HTML emite una página renderizada para un navegador. Ambas se
construyen a partir del mismo #[derive(Model)], y puedes servir un modelo de ambas formas a la
vez.
Cada tipo de vista (ListView, DetailView, CreateView, UpdateView,
DeleteView) cubre un caso estándar y renderiza mediante plantillas
Tera.
¿Nuevo con algún término aquí? Si modelo, plantilla, router o renderizado en el servidor no te resultan familiares, el glosario explica cada uno en lenguaje sencillo.
Fuente:
rustango::template_views(ListView,DetailView,CreateView,UpdateView,DeleteView,TemplateView,RedirectView) — tras la característicatemplate_views(activada por defecto).Versión ejecutable: el ejemplo API-vs-HTML de abajo está fijado por el test del framework
html_and_api_contrast_sqlite_live.rs(cargo test -p rustango --features sqlite --test html_and_api_contrast_sqlite_live). Las vistas individuales están cubiertas portemplate_view.rsytemplate_views_context_object_name_sqlite_live.rs.
Tabla de contenidos
- Vistas de API vs vistas HTML — ¿cuál quieres?
- Las cinco vistas de modelo
- ListView · DetailView
- CreateView, UpdateView, DeleteView
- El contexto de Tera
- TemplateView y RedirectView
- Mono-inquilino vs multi-inquilino
- Servir un modelo de ambas formas
- Páginas de error
- Véase también
Vistas de API vs vistas HTML — ¿cuál quieres?
Esta es la primera decisión. Ambas convierten un modelo en endpoints; difieren en qué sale y quién llama.
| Vista de API — ViewSet | Vista HTML — esta guía | |
|---|---|---|
| Módulo | rustango::viewset | rustango::template_views |
| Devuelve | datos JSON | una página HTML renderizada en el servidor |
| Pensada para | SPAs, apps móviles, otros servicios | navegadores, sitios renderizados en el servidor, CRUD tipo admin |
| Una «creación» | POST JSON → 201 + el nuevo objeto | POST de un formulario → redirección 303 a una página de éxito |
| Ante una entrada inválida | 422 + un mapa de errores JSON indexado por campo | vuelve a renderizar el formulario con los errores mostrados |
| Lee un listado como | un sobre JSON paginado | una <table>/bucle en tu plantilla |
| Habitualmente autenticada con | tokens / JWT / claves de API | cookies de sesión |
No tienes que elegir globalmente — elige por recurso, y puedes montar ambas sobre el mismo modelo (ver abajo). Reglas generales:
- Construyes un backend JSON para un framework de frontend o app móvil → ViewSet.
- Construyes un sitio renderizado en el servidor (el servidor devuelve páginas HTML) → vistas HTML.
- Necesitas ambas (una API pública y páginas CRUD internas) → monta ambas.
¿Buscas el lado JSON? Tiene su propia inmersión: ViewSets — APIs REST CRUD.
Las cinco vistas de modelo
Cada vista es for_model(SCHEMA) más un .router(prefix, tera, pool). Montarlas en el mismo
prefix (digamos /posts) da el conjunto clásico de URLs CRUD:
| Vista | Renderiza | Rutas montadas | Plantilla por defecto |
|---|---|---|---|
ListView | un listado paginado | GET <prefix> | <table>_list.html |
DetailView | una fila | GET <prefix>/{pk} | <table>_detail.html |
CreateView | un formulario de nuevo registro | GET/POST <prefix>/new | <table>_form.html |
UpdateView | un formulario de edición rellenado | GET/POST <prefix>/{pk}/edit | <table>_form.html |
DeleteView | una página de confirmación | GET/POST <prefix>/{pk}/delete | <table>_confirm_delete.html |
<table> es el nombre de la tabla del modelo, así que un Post (tabla posts) busca
posts_list.html, posts_detail.html, y así sucesivamente. Reemplaza cualquiera de ellas con
.template("my_name.html").
Quién puede usar una vista
Una vista de modelo no se monta hasta que dices quién puede usarla, así ninguna página sale abierta por accidente. Llama a una de estas en cada vista:
| Llamada | Quién entra |
|---|---|
.allow_anonymous() | cualquiera que llegue al router; pon tu propia capa de auth delante si hace falta (ejemplo) |
.login_required() | cualquier usuario con sesión; los demás reciben 401 |
.permissions(&["posts.change"]) | un usuario con sesión que tenga cada codename; los superusuarios pasan |
.permissions_for_model() | el codename del modelo: view para List y Detail, add, change, delete para las vistas de escritura |
Las tres últimas requieren la feature tenancy y van en .tenant_router(..):
allí el usuario viene de require_auth / optional_auth o de la cookie de
sesión y debe pertenecer a ese tenant. En un .router(prefix, tera, pool) con
pool fijo solo cuenta un usuario que tu propia capa de auth de base única puso
en la petición; el usuario de un tenant recibe 403. Con
permissions_for_model(), un ListView con .bulk_actions(true) necesita
view, change y delete para su POST. Para enviar a los visitantes anónimos a
una página de login en vez de un 401, envuelve el router en auth_decorators::login_required("/login").
Las vistas aplican las mismas reglas de fila que un ViewSet: los scopes
register_queryset_scope! acotan cada lectura y escritura, y el hook view
oculta filas (404 en las páginas de detalle, edición y borrado; fuera de
listas, acciones masivas y nombres de FK mostrados). Los hooks change y
delete rechazan con un 403, y un delete_selected que incluye una fila
rechazada es un 403 entero. Un formulario no puede apuntar una FK a una fila
que los scopes o el hook view del destino ocultan (error de formulario). Una
lista revisa como máximo view_hook_scan_cap filas (2 000 por defecto) con el
hook view; por encima, la página es un 400.
ListView
Una página de listado paginado. Tú proporcionas una plantilla que itera sobre object_list;
la vista gestiona la paginación, el orden, el filtrado y la búsqueda a partir de los parámetros de
consulta.
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 correspondiente — fíjate en object_list y en las variables de paginación
que la vista estampa por ti:
<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= y ?search= funcionan igual que en un listado
ViewSet — la diferencia es puramente que el resultado es una página renderizada en lugar de un
sobre JSON. Usa .context_object_name("posts") si prefieres iterar sobre posts en vez de sobre
object_list en la plantilla.
El tamaño de página es 20 por defecto. Un cliente puede pedir ?page_size=N,
limitado por .max_page_size(n) (100 por defecto); una página más allá de la fila .max_offset(n) (10 000 por defecto, 0 quita el límite) responde 400. .bulk_actions(true) hace que
la lista acepte un POST con un campo action y las pk elegidas:
delete_selected viene incluida, .action(...) añade las tuyas, y
.with_delete_confirmation(true) muestra antes una página de confirmación.
.with_fk_display(true) añade un valor <column>_display por cada clave foránea,
con una consulta extra por columna FK y por página.
?ordering= es la excepción. La lista permitida de un ListView empieza vacía, así
que el parámetro se ignora hasta que nombras tú las columnas ordenables:
fn post_list() -> ListView {
ListView::for_model(Post::SCHEMA)
.allow_anonymous()
.ordering_fields(&["title", "published_at"])
}
Sin esa llamada la lista vuelve al .order_by(...) del builder, o a PK-ASC para que la
paginación siga siendo determinista. Solo se acepta una columna, con un - inicial
para orden descendente.
DetailView
Una fila, buscada a partir de la URL. Por defecto coincide con la clave primaria
(/posts/42); apúntala a otra columna con .lookup_field("slug") para URLs bonitas
(/posts/my-first-post). Una fila ausente es 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);
La plantilla recibe la fila como object:
<h1>{{ object.title }}</h1>
<p>{{ object.body }}</p>
<small>by author #{{ object.author_id }}</small>
CreateView, UpdateView, DeleteView
El lado de escritura. Cada una gestiona un GET (renderizar un formulario / página de
confirmación) y un POST (hacer el trabajo, luego redirigir). La redirección-tras-POST es el
patrón estándar Post/Redirect/Get — evita que un refresco del navegador vuelva a enviar.
CreateView — GET /posts/new renderiza un formulario vacío; POST /posts/new
inserta la fila y hace un 303 a 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 lista de campos es obligatoria. Es la lista blanca de escritura: el formulario
muestra solo esos campos y cualquier otra clave enviada (por ejemplo id=1)
se ignora. En UpdateView, un campo listado que no llega conserva su valor; solo un
bool pasa a false, porque una casilla sin marcar no envía nada. En CreateView,
un campo listado con default de columna que no llega recibe ese default.
Cada campo listado es entrada del usuario. Aquí el navegador envía
author_id, así que cualquiera puede publicar en nombre de otro. CreateView aún
no puede fijar un campo en el servidor: para un campo que decide el servidor (el
autor con sesión), escribe tu propio handler.
La plantilla del formulario (posts_form.html) se comparte con UpdateView. is_update
distingue las dos, y form transporta tanto los campos como cualquier mensaje de
validación:
<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>
Una escritura que la base de datos rechaza (una columna NOT NULL que el formulario omite, un CHECK) es un error de todo el formulario en form.errors.__all__, no en un campo; muéstralo, o la página vuelve sin ningún mensaje.
Aquí hay dos cosas fáciles de equivocar. form.errors asocia un nombre de campo a una
cadena, no a una lista — aplicarle join es un error. Y no existe una variable errors de
nivel superior; iterar sobre una es un fallo de renderizado de Tera, así que la página
devuelve 500 en lugar de mostrar el mensaje.
{{ csrf_input | safe }} necesita el filtro: html_tera autoescapa todas las plantillas, así que sin él el
token se renderiza como texto y todo POST es rechazado.
Validación. Las reglas del esquema (tipo, max_length, NOT NULL…) se aplican
automáticamente. Añade las tuyas con un validador de closure — ante un Err, el formulario
se vuelve a renderizar con los mensajes y un estado 422 en lugar de guardar:
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));
También puedes reutilizar los validadores de una estructura #[derive(Form)] con .form::<F>()
(solo validación por ahora — ver la documentación de la API).
UpdateView — GET /posts/{pk}/edit renderiza el mismo formulario rellenado desde la
fila (object está poblado, is_update es true); POST actualiza y hace 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 renderiza una página de confirmación
(posts_confirm_delete.html, con object); POST borra y hace 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));
Monta las cinco en el mismo prefijo y tienes un CRUD HTML completo:
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));
El contexto de Tera
Cada vista estampa un contexto consistente para que las plantillas se porten limpiamente entre ellas:
| Vista | Variables disponibles en la plantilla |
|---|---|
ListView | object_list (las filas de la página), 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) |
DetailView | object (la fila) |
CreateView | form (.fields, .errors), is_create (true), is_update (false) — sin object |
UpdateView | form (.fields, .errors), object (los campos listados, la clave primaria y los .context_fields()), pk, is_create (false), is_update (true) |
DeleteView | object (la fila a confirmar) |
Las filas se exponen como mapas planos indexados por nombre de columna ({{ post.title }}), con
el NULL de SQL renderizado como null. Usa .context_object_name("posts" / "post") para
añadir un alias más amigable junto a object_list / object.
Cada entrada de form.fields lleva name, column, ty, required, max_length y
value. form.errors está indexado por nombre de campo y contiene un mensaje por campo, no
una lista. Cada vista estampa además csrf_token y csrf_input, y cada router de vista
rechaza un POST sin un token que coincida.
Una casilla y un string blank nunca son required, ni un campo con default en un
formulario de creación: enviado vacío, toma el default de la columna.
CreateView no estampa ningún object, así que {{ object.title }} en un formulario de
creación queda indefinido en lugar de vacío — usa {{ field.value }} de form.fields, que
está poblado en ambos casos.
TemplateView y RedirectView
Dos ayudantes sin modelo para las páginas que todo sitio tiene:
TemplateView — renderiza una plantilla estática con un contexto fijo (una página «acerca de», una landing page). Sin modelo, sin base de datos:
use rustango::template_views::TemplateView;
let app = TemplateView::new("about.html")
.context_value("title", "About us")
.router("/about", Arc::new(tera));
RedirectView — una redirección permanente o temporal en una URL (para páginas movidas):
use rustango::template_views::RedirectView;
let app = RedirectView::to("/posts").router("/old-posts");
Responde 302 Found; .permanent() la convierte en 301.
FormView — un formulario sin modelo. FormView::<ContactForm>::for_form(handler)
renderiza un formulario #[derive(Form)] en GET (plantilla form.html por defecto).
En POST valida y llama a tu handler async; Ok(()) redirige con 303, y
Err(msg) vuelve a renderizar el formulario. Una entrada no válida lo vuelve a
renderizar con 422. Su contexto es errors (una lista por campo; los errores
generales bajo __all__) y values. Como en todas las vistas de aquí, .success_url es / por
defecto.
Mono-inquilino vs multi-inquilino
Cada vista de modelo trae dos constructores de router — el mismo builder, elige el que coincida con cómo tu app gestiona las conexiones a la base de datos:
.router(prefix, tera, pool)— mono-inquilino; captura un pool en el momento del montaje. Esto es lo que usan los ejemplos de arriba..tenant_router(prefix, tera)— multi-inquilino; resuelve una conexión por petición desde el extractorTenant. Disponible con las característicastemplate_views+tenancy. Las plantillas se portan sin cambios entre ambos.
Esto refleja la división de ViewSet (router vs tenant_router).
Servir un modelo de ambas formas
No estás limitado a una sola puerta de entrada. Monta una API JSON y páginas HTML sobre el mismo modelo y pool — una API pública para clientes, páginas renderizadas en el servidor para personas:
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));
Ahora GET /api/posts devuelve el sobre JSON paginado y GET /posts
devuelve un listado HTML renderizado — las mismas filas, el mismo pool, dos formas. Esta
configuración exacta es lo que afirma el test de respaldo.
Páginas de error
Una capa convierte cada 4xx/5xx de tu app en una página para personas y deja en
paz a los clientes de API. Está desactivada por defecto; nada cambia hasta
que la activas. Necesita la feature template_views.
Activarla
En el servidor multi-inquilino, la capa lo envuelve todo: tu API, el login del inquilino, el admin del inquilino, la consola de operador y las capas propias del 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 hace lo mismo para una app de un solo pool. En un
router propio, móntala con ErrorPagesRouterExt y añade el 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()));
Con Cli y un archivo de configuración, usa en su lugar la sección [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 directorio templates que no existe se omite sin aviso; uno que no se parsea
queda en el log. En ambos casos se usan las páginas integradas.
cargo rustango new escribe [errors] enabled = true en config/default.toml, así
que un proyecto nuevo tiene las páginas activadas. Los proyectos antiguos siguen sin
ellas hasta que añaden la sección.
Qué recibe cada cliente
| Petición | Respuesta |
|---|---|
Navegación del navegador (Accept: text/html, sin HX-Request) | Página HTML completa |
htmx (HX-Request) | Fragmento HTML, más HX-Retarget: <htmx_target> y HX-Reswap: innerHTML show:window:top |
Cualquier otro cliente (fetch, curl) | El cuerpo sin cambios; un cuerpo vacío recibe el mensaje como texto plano |
| JSON / problem+json | Sin cambios, salvo que lleve un Message y pregunte un navegador o htmx |
HEAD | Sin cambios |
Una respuesta marcada con rustango::errors::KeepBody | Sin cambios |
También se reemplaza un cuerpo de error text/html, salvo que la respuesta
lleve KeepBody: marca toda página de error HTML que construyas tú.
Solo se reemplazan cuerpos de texto (text/plain, text/html, ninguno) y JSON
con mensaje; imágenes y otros tipos pasan. Una respuesta vestida conserva su
estado y cabeceras (también Retry-After) y recibe Vary: Accept, HX-Request.
Plantillas
Gana la primera plantilla que exista en tu Tera:
errors/<code>.html, p. ej.errors/404.htmlerrors/4xx.htmloerrors/5xx.htmlerrors/default.html- la página integrada
Los fragmentos htmx usan errors/partial.html y luego el fragmento integrado.
Una plantilla que falla al renderizar queda en el log y se usa la página
integrada; una página de error nunca vuelve vacía.
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 %}
Contexto:
| Clave | Valor |
|---|---|
code | El estado, p. ej. 404 |
title | Un título corto por estado («Not found») |
message | Qué salió mal, para el usuario (ver abajo) |
path | La ruta de la petición |
user | { username, is_superuser } del usuario del inquilino con sesión, o null |
username, is_superuser | Lo mismo, plano |
csrf_token, csrf_input | Un token CSRF y su input oculto, con el nombre de cookie de tu capa CSRF. La cookie solo se pone si la plantilla los usa |
csp_nonce | El nonce CSP de esta petición, o "" |
brand_name, brand_logo_url, brand_css, theme_mode | De [brand] |
user necesita la feature tenancy y un host de inquilino; en otro caso es
null. Las plantillas son por app: todos los inquilinos reciben las mismas.
La página integrada
HTML autónomo: sin CDN, sin script, CSS inline con el nonce CSP de la petición,
los tokens de tema del admin (claro y oscuro). Con [errors] en los settings
muestra [brand] name y logo_url; primary_color y theme_mode fijan los
colores (necesitan la feature tenancy, cuyo código de marca reutiliza).
ErrorPagesLayer::brand(&settings.brand) hace lo mismo en código.
El mensaje
Un handler le da palabras a la página con rustango::errors::Message, una
extensión de respuesta, o con PageError, que lleva uno:
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."))
}
Sin Message, un cuerpo 4xx text/plain de hasta 2 KiB es el mensaje (los
rechazos de axum, la comprobación CSRF); si no, el texto por defecto del estado.
La primera letra pasa a mayúscula.
Un 5xx nunca muestra su causa: la página usa el texto genérico, y
PageError::server(e) registra e y envía el mismo cuerpo opaco que cualquier
otro 5xx. Solo cuando RUSTANGO_DISCLOSE_ERRORS está definida una página 5xx
muestra su mensaje o su cuerpo — la misma regla que para cualquier cuerpo 5xx
del framework.
PageError::forbidden(msg) y PageError::new(status, msg) cubren otros
estados. ErrorPagesLayer::htmx_swap(..) cambia el valor de HX-Reswap.
Qué cubre
Montada con Builder::error_pages (o [errors]), la capa queda dentro de las
cabeceras de seguridad y fuera de todo lo demás, así que viste:
- rutas y hosts desconocidos (404), y los 405;
- el 500 del panic guard;
- el 403 de la capa CSRF, con su motivo;
- las guardas
login_required_or_401/*_or_403(401, 403); - el límite de cuerpo (413), el timeout de petición (504), el rate limit y el throttle de login (429);
- los rechazos de axum (400, 415, 422);
- las denegaciones y 404 del admin del inquilino, y las rutas desconocidas de la consola de operador.
Las páginas con sus propios controles conservan su aspecto: toda página de
error HTML del admin, del admin de tenant, de la consola de operador y de las
vistas genéricas, como un formulario mostrado de nuevo con su error, la página
«admin access required» (tiene un formulario para cerrar sesión) y la página
«table not migrated». Marca tus propias respuestas con KeepBody para hacer lo
mismo.
Migrar desde un middleware de errores escrito a mano
Una app que tenía su propio middleware error_pages puede borrar:
- el middleware (
from_fn(error_pages)) y su.fallback(not_found); - su tabla de títulos/mensajes:
rustango::errors::error_wordses la misma tabla; - su extensión de mensaje privada: devuelve
PageErroroMessage; - el clonado de cabeceras/extensiones que hacía para poner el CSRF y encontrar al usuario.
Conserva templates/error.html como templates/errors/default.html y la alerta
htmx como templates/errors/partial.html; las claves del contexto son las mismas.
Véase también
- ViewSets — APIs REST CRUD — la contraparte JSON/API, en profundidad.
- Admin — el admin autogenerado se construye sobre estas mismas vistas.
- URLs y enrutamiento — cómo componer estos routers en tu app.
- Serializadores — da forma al JSON cuando tomas la ruta de la API.
