4. Enrutamiento
4.1. Ejemplo 17: el enrutador
Una aplicación [React] es una aplicación de página única: el navegador carga una SOLA página HTML. Cuando se hace clic en un enlace interno, no se envía ninguna solicitud al servidor: el enrutador cambia la dirección que muestra el navegador y reemplaza el componente mostrado. [React] no tiene un enrutador: en su lugar se usa la biblioteca [React Router] (paquete [react-router]), que es la más utilizada.
[React Router] se puede usar de tres maneras (sus “modos”): declarativo (con los componentes [<Routes>] y [<Route>], el más simple), “de datos” (rutas descritas mediante objetos, con funciones que se ejecutan antes del renderizado: [loader], [middleware]...) y “framework” (una aplicación completa con renderizado en el servidor, similar a [Next.js]). Usamos el modo de datos, que ofrece los controles de navegación que necesitaremos.
4.1.1. Los datos
| // datos "fijos en el código", para no depender de un servidor en este ejemplo
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
}
export const DOCTORS: Doctor[] = [
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];
|
Datos “escritos directamente en el código”, para no depender de un servidor en este ejemplo.
4.1.2. Las rutas
| // =========================================================================
// 17-router/src/routes.tsx - las RUTAS de la aplicación
// -------------------------------------------------------------------------
// Una aplicación React es una aplicación de página única (SPA: Single
// Page Application): el navegador solo carga UNA página HTML. Cuando se
// hace clic en un enlace interno, no se envía ninguna solicitud al servidor: el
// enrutador cambia la dirección mostrada por el navegador y reemplaza el
// componente mostrado en <Outlet />.
//
// React no tiene enrutador: se usa la biblioteca React Router. Una
// ruta asocia una RUTA DE ACCESO (path) con un COMPONENTE (una "página"):
// 'doctors/:id' :id es un parámetro (/doctors/2 -> id = "2");
// '*' cualquier ruta de acceso: la página "no encontrado" (el
// enrutador siempre elige la ruta más específica).
// Las rutas están ANIDADAS: la ruta raíz muestra el armazón de
// la aplicación (Shell), y sus hijas se muestran dentro de él, en
// el lugar de su <Outlet />.
// =========================================================================
import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import DoctorList from './pages/DoctorList';
import DoctorDetail from './pages/DoctorDetail';
import Search from './pages/Search';
import NotFoundPage from './pages/NotFoundPage';
export const routes: RouteObject[] = [
{
path: '/',
Component: Shell,
children: [
// index: la ruta de la dirección del propio padre ("/")
{ index: true, Component: Home },
{ path: 'doctors', Component: DoctorList },
{ path: 'doctors/:id', Component: DoctorDetail },
{ path: 'search', Component: Search },
// carga DIFERIDA: el código de esta página solo se descarga en la
// primera visita (Vite genera un archivo aparte para ella)
{ path: 'about', lazy: async () => ({ Component: (await import('./pages/About')).default }) },
// una redirección: la dirección antigua lleva a la nueva. Un LOADER
// es una función que el enrutador llama ANTES de mostrar la ruta;
// si lanza una redirección, la navegación cambia de destino
{
path: 'physicians',
loader: () => {
throw redirect('/doctors');
},
},
{ path: '*', Component: NotFoundPage },
],
},
];
|
- Línea 20: [RouteObject] es el tipo de una ruta; [redirect] crea una redirección;
- líneas 28–53: las rutas son objetos: una ruta de acceso ([path]) y un componente ([Component], con mayúscula inicial: se especifica el componente, no [<Home />]);
- líneas 30–32: las rutas están anidadas: la ruta raíz muestra el “armazón” de la aplicación ([Shell]), y sus hijas ([children]) se muestran DENTRO del armazón, en el lugar de su [<Outlet />]. Las rutas de acceso de las hijas son relativas a la del padre;
- línea 34: una ruta index: la de la dirección del propio padre (“/”);
- línea 36: [:id] es un parámetro: [/doctors/2] muestra [DoctorDetail], donde [id] = “2”;
- línea 40: carga diferida: la función [lazy] se llama solo en la primera visita a la página. [import('./pages/About')] (una importación “dinámica”, en forma de función) descarga entonces el módulo, que [Vite] ha guardado en un archivo aparte. [lazy] devuelve las propiedades faltantes de la ruta: en este caso, su componente, que el módulo exporta por defecto;
- líneas 45–49: una redirección: la dirección antigua lleva a la nueva. Un loader es una función que el enrutador llama ANTES de mostrar la ruta (para cargar sus datos); si lanza ([throw]) una redirección, la navegación cambia de destino;
- línea 50: [*] corresponde a cualquier ruta de acceso: la página “no encontrada”. El enrutador siempre elige la ruta más específica: el orden de las rutas no importa.
4.1.3. Arranque
| // =========================================================================
// 17-router/src/main.tsx
// -------------------------------------------------------------------------
// createBrowserRouter(routes) construye el enrutador, que sigue la dirección del
// navegador; <RouterProvider> muestra la ruta que corresponde a la dirección
// actual. El componente raíz ya no es App: son las rutas.
// =========================================================================
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';
const router = createBrowserRouter(routes);
createRoot(document.getElementById('root')!).render(
<StrictMode>
<RouterProvider router={router} />
</StrictMode>,
);
|
- línea 16: el enrutador, construido a partir de las rutas. [Browser]: sigue la dirección del navegador mediante la API [history];
- línea 20: el componente que muestra la ruta correspondiente a la dirección actual. El componente raíz ya no es [App]: son las rutas. [RouterProvider] se importa desde [react-router/dom], la parte de la biblioteca específica del navegador.
4.1.4. El armazón de la aplicación
| // =========================================================================
// 17-router/src/Shell.tsx - el "armazón" de la aplicación
// -------------------------------------------------------------------------
// - <Link to="...">, <NavLink to="...">: un enlace interno. Produce un
// <a href> real, pero un clic no recarga la página: es el enrutador
// quien actúa. NavLink también sabe si apunta a la página mostrada:
// entonces pone la clase "active" (la de Bootstrap);
// - <Outlet />: el marcador de posición donde se muestra la ruta HIJA actual;
// - useLocation(): la dirección actual (pathname, search...).
// =========================================================================
import { NavLink, Outlet, useLocation } from 'react-router';
export default function Shell() {
const location = useLocation();
// decodeURIComponent: %20 vuelve a ser un espacio
const address = decodeURIComponent(location.pathname + location.search);
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 17 - the router</h1>
<nav className="nav nav-pills mb-3">
{/* end: "/" solo está activo exactamente en "/", y no en /doctors */}
<NavLink className="nav-link" to="/" end>Home</NavLink>
<NavLink className="nav-link" to="/doctors">Doctors</NavLink>
{/* los parámetros después del ?: NavLink solo compara la ruta de acceso */}
<NavLink className="nav-link" to="/search?q=general practitioner">Search</NavLink>
<NavLink className="nav-link" to="/about">About</NavLink>
<NavLink className="nav-link" to="/physicians">/physicians (redirect)</NavLink>
<NavLink className="nav-link" to="/unknown-page">Broken link</NavLink>
</nav>
<p className="small text-muted">current address: <code>{address}</code></p>
<div className="card p-3">
<Outlet />
</div>
</div>
);
}
|
- línea 15: [useLocation()] devuelve la dirección actual: [pathname] (la ruta de acceso), [search] (la parte posterior al “?”)... El componente se llama cada vez que el usuario navega;
- Línea 24: [<NavLink to="...">] es un enlace interno. Genera un [<a href>] válido (que se puede abrir en una pestaña nueva), pero al hacer clic no se recarga la página: el enrutador se encarga de ello. [NavLink] también sabe si se refiere a la página mostrada actualmente: en ese caso, agrega la clase [active] (la misma que en [Bootstrap]). [end]: la página de inicio “/” está activa solo en “/” exactamente, y no en [/doctors]; [<Link>] es la versión simple, sin clase activa;
- línea 27: una dirección con parámetros. [NavLink] compara solo la ruta de acceso: el enlace permanece activo sin importar la búsqueda;
- línea 34: el lugar donde se muestra la ruta HIJA actual.
4.1.5. Las páginas
La página de inicio:
| // React 19: un elemento <title> escrito en un componente es colocado por React
// en el <head> de la página; cambia el título de la pestaña mientras el
// componente esté mostrado
export default function Home() {
return (
<>
<title>Home</title>
<p className="mb-0">
Welcome. Click on the links: the address of the browser changes, the page is never reloaded (open
the Network tab of the developer tools to check it). The Back and Forward buttons of the browser
work, as well as the reloading (F5) of any page.
</p>
</>
);
}
|
- línea 7: [React] coloca cualquier elemento escrito en un componente en el [<head>] de la página, mientras el componente esté mostrado: así, cada página define el título de la pestaña (se puede hacer lo mismo con [<meta>] y [<link>]).
La lista de médicos, con enlaces parametrizados:
| // 17-router/src/pages/DoctorList.tsx - enlaces con un parámetro
import { Link } from 'react-router';
import { DOCTORS } from '../data';
export default function DoctorList() {
return (
<>
<title>Doctors</title>
<ul className="mb-0">
{DOCTORS.map((m) => (
// una plantilla de cadena construye la dirección /doctors/2
<li key={m.id}>
<Link to={`/doctors/${m.id}`}>{m.title} {m.firstName} {m.lastName}</Link>
</li>
))}
</ul>
</>
);
}
|
Una plantilla de cadena genera la dirección [/doctors/2].
El perfil de un médico:
| // =========================================================================
// 17-router/src/pages/DoctorDetail.tsx - una página con un parámetro
// -------------------------------------------------------------------------
// useParams(): los parámetros de la ruta de acceso, aquí { id: "2" } - siempre
// CADENAS. useNavigate(): una función para navegar MEDIANTE CÓDIGO;
// navigate(-1) vuelve a la página anterior, como el botón Atrás.
// Si se pasa de /doctors/1 a /doctors/2, React REUTILIZA el mismo
// componente: simplemente se llama de nuevo con otro id.
// =========================================================================
import { useNavigate, useParams } from 'react-router';
import { DOCTORS } from '../data';
export default function DoctorDetail() {
const { id } = useParams();
const navigate = useNavigate();
const doctor = DOCTORS.find((m) => m.id === Number(id));
if (!doctor) {
return <p className="text-danger mb-0">Doctor no. {id} does not exist.</p>;
}
const next = (doctor.id % DOCTORS.length) + 1;
return (
<>
<title>{`${doctor.firstName} ${doctor.lastName}`}</title>
<h2 className="h5">{doctor.title} {doctor.firstName} {doctor.lastName}</h2>
<p>Specialty: {doctor.specialty}</p>
<div className="d-flex gap-2">
<button className="btn btn-sm btn-outline-secondary" onClick={() => navigate(-1)}>Back</button>
<button className="btn btn-sm btn-outline-primary" onClick={() => navigate(`/doctors/${next}`)}>Next doctor</button>
</div>
</>
);
}
|
- Línea 15: [useParams()] proporciona los parámetros de la ruta (en este caso, [{ id: "2" }]), siempre en formato de cadena;
- línea 16: una función para navegar mediante código;
- líneas 19–21: un médico desconocido ([/doctors/9]): un mensaje;
- línea 26: un título calculado: [<title>] solo acepta UNA cadena, de ahí la plantilla;
- línea 30: [navigate(-1)] vuelve a la página anterior, como el botón Atrás del navegador;
- línea 31: navegar a una dirección. Pasar de [/doctors/1] a [/doctors/2] no recrea el componente: [React] simplemente lo vuelve a renderizar, con un [id] distinto.
La búsqueda:
| // =========================================================================
// 17-router/src/pages/Search.tsx - una página controlada por la URL
// -------------------------------------------------------------------------
// /search?q=pediatrician: como con el formulario GET del curso de NestJS, la
// página queda descrita por completo por su dirección: se puede guardar como marcador,
// recargar, volver a ella con el botón Atrás. useSearchParams() da los
// parámetros después del ?.
// <Form> (de React Router) es un formulario GET... sin recarga: el
// enrutador navega a /search?q=<input>. La página muestra lo que dice la
// URL, y nada más.
// =========================================================================
import { Form, useSearchParams } from 'react-router';
import { DOCTORS } from '../data';
export default function Search() {
const [params] = useSearchParams();
const q = params.get('q') ?? ''; // null si está ausente
const results = DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q.toLowerCase()));
return (
<>
<title>Search</title>
<Form className="d-flex gap-2 mb-3" action="/search">
{/* un campo NO controlado, que empieza con el valor de la URL;
key={q}: si la URL cambia (botón Atrás), React vuelve a crear el
campo, que entonces toma el nuevo valor de la URL */}
<input key={q} name="q" className="form-control" placeholder="name or specialty" defaultValue={q} />
<button className="btn btn-primary">Search</button>
</Form>
<ul className="mb-0">
{results.map((m) => (
<li key={m.id}>{m.firstName} {m.lastName} ({m.specialty})</li>
))}
{results.length === 0 && <li className="text-muted">No result.</li>}
</ul>
</>
);
}
|
- Línea 17: los parámetros posteriores al “?”, en forma de un objeto [URLSearchParams]: [params.get('q')] es igual a [null] si [q] está ausente. [useSearchParams] también devuelve (como segundo elemento) una función para cambiarlos;
- línea 24: [<Form>] (de [React Router]) es un formulario GET... sin recarga: al enviarlo, el enrutador navega a [/search?q=<input>] ([q] es el [name] del campo). Como con el formulario GET del curso de [NestJS], la página queda totalmente descrita por su dirección: se puede guardar en marcadores, recargar o volver atrás;
- Línea 28: el campo no está controlado; parte con el valor de la URL ([defaultValue]). Si la URL cambia sin que se recargue la página (con el botón Atrás), el campo conservaría su texto anterior; [key={q}] resuelve este problema. Cuando cambia la clave de un elemento, [React] lo trata como un elemento DISTINTO: destruye el anterior y crea uno nuevo, que parte con el nuevo valor por defecto. Es un truco habitual para “reiniciar” un componente.
La página bajo demanda y la página “no encontrada”:
| // 17-router/src/pages/About.tsx - una página cargada bajo demanda
// "export default": la ruta la encuentra mediante (await import(...)).default
export default function About() {
return (
<>
<title>About</title>
<p className="mb-0">
This page was downloaded on the first visit (Network tab: a file About-XXXX.js in production).
Its tab title comes from the title element it contains.
</p>
</>
);
}
|
| import { useLocation } from 'react-router';
export default function NotFoundPage() {
const { pathname } = useLocation();
return (
<>
<title>Page not found</title>
<p className="text-danger mb-0">No page at the address <code>{pathname}</code>.</p>
</>
);
}
|
4.1.6. Ejecución
Haga clic en “Doctors” y luego en “Mr Paul TATOU”: la dirección cambia a [/doctors/2], y el título de la pestaña pasa a ser “Paul TATOU”:

Una búsqueda: la dirección pasa a ser [/search?q=pediatrician]:

“About”: en desarrollo, el módulo [About.tsx] se descarga solo en la primera visita (pestaña Red de las herramientas de desarrollo); en producción ([npm run build 17-router]), se guarda en un archivo aparte:
| 17-router/dist/index.html 0.38 kB │ gzip: 0.26 kB
17-router/dist/assets/index-CqLr8KVv.css 230.06 kB │ gzip: 30.68 kB
17-router/dist/assets/About-DBg63tlb.js 0.36 kB │ gzip: 0.26 kB
17-router/dist/assets/index-evhjxpxc.js 317.05 kB │ gzip: 100.09 kB
|

“/physicians” lleva a [/doctors]; un enlace roto:

Se puede recargar (F5) cualquier página: el servidor de desarrollo [Vite] devuelve [index.html] para cualquier dirección desconocida, y el enrutador muestra la página correcta. En producción, el servidor deberá hacer lo mismo (véase el capítulo “Despliegue”).
4.2. Ejemplo 18: controles de navegación
Algunas páginas exigen que el usuario haya iniciado sesión o tenga un rol específico. El enrutador puede verificarlo antes de mostrarlas, mediante middleware.
4.2.1. La sesión
| // =========================================================================
// 18-guards/src/session.ts - una sesión SIMULADA (sin servidor)
// -------------------------------------------------------------------------
// El usuario conectado debe ser conocido por los COMPONENTES (la barra superior,
// la página de agenda) y por los GUARDIAS (funciones del enrutador, que no
// son componentes y por lo tanto no pueden leer un contexto). Se almacena
// en un módulo simple, un "store" hecho a mano:
// - una variable privada, el estado;
// - funciones para leerlo y modificarlo;
// - subscribe: la lista de las funciones a notificar cuando cambia.
// Un componente se suscribe a él con useSyncExternalStore (cf. useSession): se
// vuelve a llamar cuando cambia el estado. El ejemplo 20 confiará este trabajo a una
// biblioteca, Zustand. (El ejemplo 23 hará lo mismo con un
// servidor real.)
// =========================================================================
import { useSyncExternalStore } from 'react';
export type Role = 'ADMIN' | 'DOCTOR' | 'USER';
export interface User {
login: string;
role: Role;
}
// tres cuentas "fijas en el código" (contraseña = login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };
let user: User | null = null; // el estado
const subscribers = new Set<() => void>();
function setUser(u: User | null) {
user = u;
subscribers.forEach((notify) => notify());
}
export const session = {
user: () => user,
logIn(login: string, password: string): boolean {
const role = Object.hasOwn(ACCOUNTS, login) ? ACCOUNTS[login] : undefined;
if (role === undefined || password !== login) {
return false;
}
setUser({ login, role });
return true;
},
logOut: () => setUser(null),
subscribe(notify: () => void) {
subscribers.add(notify);
return () => subscribers.delete(notify); // para cancelar la suscripción
},
};
// el hook de los componentes: el usuario conectado, siempre actualizado
export function useSession(): User | null {
return useSyncExternalStore(session.subscribe, session.user);
}
|
El usuario con sesión iniciada debe ser conocido por los componentes (la barra superior, la página de la agenda) y por los guardias, funciones del enrutador que no son componentes y, por lo tanto, no pueden leer un contexto. Se almacena en un módulo simple, escrito a mano, un store ([store]):
- líneas 29–30: el estado, una variable privada del módulo, y la lista de funciones a las que se notifica cuando cambia;
- líneas 32–35: cambian el estado y notifican a los suscriptores;
- líneas 37–52: las funciones públicas: leer el usuario, iniciar sesión (tres cuentas escritas directamente en el código, contraseña = login), cerrar sesión y suscribirse ([subscribe] devuelve la función que cancela la suscripción);
- líneas 55–57: el hook del componente. [useSyncExternalStore(subscribe, read)] es el hook de [React] diseñado para este propósito: suscribe el componente al store y lo vuelve a llamar cuando cambia el valor leído.
El ejemplo 20 delegará esta tarea a una biblioteca.
4.2.2. Los guardias
| // =========================================================================
// 18-guards/src/guards.ts - GUARDIAS de navegación
// -------------------------------------------------------------------------
// Un MIDDLEWARE de React Router es una función que el enrutador llama
// ANTES de mostrar una ruta que lo declara (middleware: [...]), en CADA
// navegación hacia ella. Puede:
// - no hacer nada: la navegación continúa;
// - lanzar una redirección, redirect('/dirección'): la
// navegación se reemplaza por una navegación a esa dirección.
// Recibe la solicitud de navegación (request.url: la dirección solicitada).
//
// Es el equivalente en el cliente de los guardias de NestJS (JwtAuthGuard,
// RolesGuard) - con una diferencia FUNDAMENTAL: un guardia del cliente es
// solo una comodidad. El código del cliente está en manos del usuario, quien
// puede modificarlo a voluntad. La verdadera protección de los datos sigue siendo la
// del SERVIDOR (cf. capítulo sobre la caja negra).
// =========================================================================
import { redirect, type MiddlewareFunction } from 'react-router';
import { session, type Role } from './session';
// la dirección solicitada, sin el host: "/schedule?x=1"
function address(request: Request): string {
const url = new URL(request.url);
return url.pathname + url.search;
}
// la página requiere haber iniciado sesión
export const requireLogin: MiddlewareFunction = ({ request }) => {
if (session.user() === null) {
// sin sesión iniciada: a la página de inicio de sesión, recordando adónde queríamos ir
throw redirect(`/login?redirect=${encodeURIComponent(address(request))}`);
}
};
// la página requiere uno de los roles dados: una función que CONSTRUYE el guardia
export function requireRole(...roles: Role[]): MiddlewareFunction {
return ({ request }) => {
const u = session.user();
if (u === null || !roles.includes(u.role)) {
// con sesión iniciada, pero sin el rol adecuado: de vuelta al inicio, con un motivo
throw redirect(`/?denied=${encodeURIComponent(address(request))}`);
}
};
}
|
Un middleware de [React Router] es una función que el enrutador llama ANTES de mostrar una ruta que lo declara, en CADA navegación hacia ella. Puede no hacer nada (la navegación continúa) o provocar una redirección, que reemplaza la navegación.
- Líneas 23–26: recibe la solicitud de navegación: [request.url] es la dirección completa solicitada ([http://localhost:5173/schedule?x=1]); solo se conservan la ruta de acceso y los parámetros;
- líneas 29–34: sin sesión iniciada: redirige a la página de inicio de sesión, conservando el destino previsto ([?redirect=...]);
- líneas 37–45: una función que CONSTRUYE el guardia para los roles dados; [...roles]: cualquier cantidad de argumentos, agrupados en un arreglo. Con sesión iniciada, pero sin el rol correcto: redirige a la página de inicio, con un motivo.
Este es el equivalente del lado del cliente de los guardias de [NestJS] ([JwtAuthGuard], [RolesGuard]), con una diferencia: un guardia del lado del cliente es solo una comodidad. El código del cliente está en manos del usuario, quien puede modificarlo a voluntad. La verdadera protección de los datos sigue siendo la que ofrece el SERVIDOR (véase el capítulo sobre la caja negra).
4.2.3. Rutas protegidas
| // =========================================================================
// 18-guards/src/routes.tsx - rutas PROTEGIDAS
// -------------------------------------------------------------------------
// middleware: los guardias que hay que pasar, en orden. Una página cargada bajo
// demanda (lazy) solo se descarga una vez superados los guardias.
// =========================================================================
import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import Login from './pages/Login';
import Schedule from './pages/Schedule';
import { requireLogin, requireRole } from './guards';
export const routes: RouteObject[] = [
{
path: '/',
Component: Shell,
children: [
{ index: true, Component: Home },
{ path: 'login', Component: Login },
{ path: 'schedule', Component: Schedule, middleware: [requireLogin] },
{
path: 'administration',
middleware: [requireLogin, requireRole('ADMIN')],
lazy: async () => ({ Component: (await import('./pages/Administration')).default }),
},
// cualquier otra dirección: de vuelta al inicio
{ path: '*', loader: () => redirect('/') },
],
},
];
|
- línea 22: los guardias de la ruta, ejecutados en orden;
- líneas 24–26: una página cargada bajo demanda se descarga solo después de pasar los guardias;
- línea 29: cualquier otra dirección: regreso a la página de inicio. Un loader también puede DEVOLVER la redirección.
El código de arranque es el mismo que en el ejemplo 17:
| import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';
const router = createBrowserRouter(routes);
createRoot(document.getElementById('root')!).render(
<StrictMode>
<RouterProvider router={router} />
</StrictMode>,
);
|
4.2.4. El armazón y las páginas
| // 18-guards/src/Shell.tsx - los enlaces y el usuario conectado
import { NavLink, Outlet, useNavigate } from 'react-router';
import { session, useSession } from './session';
// NavLink acepta una FUNCIÓN para className: recibe { isActive }
const cssClass = ({ isActive }: { isActive: boolean }) => (isActive ? 'fw-bold' : '');
export default function Shell() {
const user = useSession();
const navigate = useNavigate();
function onLogOut() {
session.logOut();
navigate('/');
}
return (
<div className="container py-4" style={{ maxWidth: 720 }}>
<h1 className="h3 mb-3">Example 18 - navigation guards</h1>
<nav className="d-flex gap-3 align-items-center mb-3">
<NavLink to="/" end className={cssClass}>Home</NavLink>
<NavLink to="/schedule" className={cssClass}>Schedule (logged in)</NavLink>
<NavLink to="/administration" className={cssClass}>Administration (ADMIN)</NavLink>
<span className="ms-auto">
{user ? (
<>
{user.login} <span className="badge text-bg-primary">{user.role}</span>
<button className="btn btn-sm btn-link" onClick={onLogOut}>log out</button>
</>
) : (
<NavLink to="/login">log in</NavLink>
)}
</span>
</nav>
<div className="card p-3"><Outlet /></div>
</div>
);
}
|
- Línea 6: [className] de un [NavLink] puede ser una función que recibe [{ isActive }] como entrada y devuelve las clases;
- Línea 9: el usuario con sesión iniciada; la barra sigue sus cambios;
- Líneas 12–15: cierre de sesión y regreso a la página de inicio.
| import { useSearchParams } from 'react-router';
export default function Home() {
// ?denied=...: puesto por el guardia requireRole cuando el rol no corresponde
const denied = useSearchParams()[0].get('denied');
return (
<>
{denied && <p className="alert alert-danger">Your role does not allow you to open {denied}.</p>}
<p className="mb-0">
Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).
</p>
</>
);
}
|
| import { useSession } from '../session';
export default function Schedule() {
const user = useSession();
return (
<p className="mb-0">
The schedule of <strong>{user?.login}</strong>: this page requires being logged in.
</p>
);
}
|
| export default function Administration() {
return (
<p className="mb-0">
Administration: page reserved for the ADMIN role, loaded on demand (Network tab: its file is only downloaded
on the first visit, and only if the guards allowed it).
</p>
);
}
|
| // =========================================================================
// 18-guards/src/pages/Login.tsx
// -------------------------------------------------------------------------
// Tras iniciar sesión, el usuario es enviado de vuelta a la página que quería
// abrir (parámetro ?redirect=... puesto por el guardia), o al inicio.
// =========================================================================
import { useState, type FormEvent } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { session } from '../session';
export default function Login() {
const redirection = useSearchParams()[0].get('redirect');
const navigate = useNavigate();
const [login, setLogin] = useState('');
const [password, setPassword] = useState('');
const [error, setError] = useState(false);
function submit(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
if (!session.logIn(login.trim(), password)) {
setError(true);
return;
}
// solo se acepta una ruta INTERNA: empieza con /, pero no con //
// (//site.com/... designa OTRO sitio) - ninguna redirección a otro sitio
const internal = redirection !== null && redirection.startsWith('/') && !redirection.startsWith('//');
navigate(internal ? redirection : '/');
}
return (
<>
{redirection && <p className="alert alert-warning">Log in to open {redirection}.</p>}
<form className="d-flex flex-wrap gap-2" onSubmit={submit}>
<input className="form-control w-auto" placeholder="login" autoComplete="username" value={login}
onChange={(e) => setLogin(e.target.value)} />
<input type="password" className="form-control w-auto" placeholder="password" autoComplete="current-password"
value={password} onChange={(e) => setPassword(e.target.value)} />
<button className="btn btn-primary">Log in</button>
</form>
{error && <p className="text-danger mt-2 mb-0">Incorrect login or password.</p>}
</>
);
}
|
- Línea 13: la dirección que se quería abrir, entregada por el guardia;
- líneas 27–28: tras iniciar sesión, se va allí... siempre que sea una ruta INTERNA (empieza con “/”, pero no con “//”, que remite a otro sitio): una URL de inicio de sesión manipulada ([/login?redirect=https://malicious-site.com]) no debe llevar fuera de la aplicación.
4.2.5. Ejecución
Sin haber iniciado sesión, haga clic en “Administration”: el guardia redirige a la página de inicio de sesión:

Inicie sesión como [martin] (rol [USER]): la verificación del rol redirige a la página de inicio:

Sesión iniciada como [admin]:
