Skip to content

4. Enrutamiento

Una aplicación [Vue.js] carga una sola página HTML. Sin embargo, la aplicación [RdvMedecins] tiene una página de inicio de sesión, una página de agenda, una página “Mi espacio”... Cada una tiene su propia URL ([/login], [/schedule], [/my-area]), que se puede guardar como marcador, y los botones Atrás y Adelante del navegador funcionan. Este es el trabajo del enrutador, la biblioteca [vue-router].

4.1. Ejemplo 13: el enrutador

El enrutador se agrega a la aplicación en [main.ts]:

// =========================================================================
// 13-router/src/main.ts
// -------------------------------------------------------------------------
// app.use(router): el enrutador se agrega a la aplicación. Los componentes
// <RouterLink> y <RouterView> pasan a ser utilizables en todas partes.
// =========================================================================

import { createApp } from 'vue';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';
import { router } from './router';

createApp(App).use(router).mount('#app');
  • Línea 13: [app.use(...)] instala una extensión ([plugin]): los componentes [<RouterLink>] y [<RouterView>], y las funciones [useRoute()] y [useRouter()], quedan disponibles en todas partes.

Los datos del ejemplo, “escritos directamente en el código”:

// 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' },
];

Las rutas:

// =========================================================================
// 13-router/src/router.ts - las RUTAS de la aplicación
// -------------------------------------------------------------------------
// Una aplicación Vue.js es una aplicación de página única (SPA: Single
// Page Application): el navegador carga solo 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 <RouterView>.
//
// Una ruta asocia una RUTA DE ACCESO (path) con un COMPONENTE (llamado "vista", en el
// sentido de una pantalla de la aplicación):
//   '/doctors/:id'        :id es un parámetro (/doctors/2 -> id = "2");
//   '/:pathMatch(.*)*'    cualquier ruta: la página "no encontrado"
//                         (la ruta más precisa siempre gana).
//
// createWebHashHistory: las direcciones se ven como /13-router/#/doctors/2.
// Todo lo que sigue al # se queda en el navegador: recargar la página (F5)
// siempre solicita de nuevo /13-router/, que existe. Es el modo más simple
// cuando el servidor no sabe nada del enrutador - aquí, el servidor de Vite, que
// sirve veinte ejemplos a la vez. El caso de estudio usará direcciones
// "limpias" (createWebHistory: /schedule, /doctors...).
// =========================================================================

import { createRouter, createWebHashHistory } from 'vue-router';
import Home from './views/Home.vue';
import DoctorList from './views/DoctorList.vue';
import DoctorDetail from './views/DoctorDetail.vue';
import Search from './views/Search.vue';
import NotFoundPage from './views/NotFoundPage.vue';

export const router = createRouter({
  history: createWebHashHistory(),
  routes: [
    { path: '/', name: 'home', component: Home },
    { path: '/doctors', name: 'doctors', component: DoctorList },
    // props: true -> el parámetro :id se pasa al componente como una PROP
    // (el componente deja entonces de depender del enrutador: más fácil de reutilizar)
    { path: '/doctors/:id', name: 'doctor', component: DoctorDetail, props: true },
    { path: '/search', name: 'search', component: Search },
    // una redirección: la dirección antigua lleva a la nueva
    { path: '/physicians', redirect: '/doctors' },
    { path: '/:pathMatch(.*)*', name: 'not-found', component: NotFoundPage },
  ],
});
  • Líneas 33–43: una ruta asocia una ruta de acceso con un componente, al que se llama “vista” (en el sentido de pantalla de una aplicación; esto no tiene nada que ver con las vistas de [Handlebars] del curso [NestJS], salvo por su función);
  • línea 34: una ruta puede tener un nombre, que es más estable que su ruta de acceso para crear enlaces;
  • Línea 38: [:id] es un parámetro: [/doctors/2] muestra [DoctorDetail] junto con [id = "2"]. La opción [props: true] lo pasa al componente como una prop: así, el componente ya no depende del enrutador;
  • línea 41: una redirección: la dirección [/physicians] lleva a [/doctors];
  • línea 42: una ruta comodín: la página “página no encontrada”. Solo recibe las direcciones que ninguna otra ruta reconoce: [vue-router] ordena las rutas según la precisión de su ruta de acceso; la más precisa tiene prioridad (aun así se coloca al final para mayor legibilidad);
  • línea 32: el modo de historial. Con [createWebHashHistory], las direcciones adoptan la forma [/13-router/#/doctors/2]: lo que sigue a [#] nunca se envía al servidor, y al recargar la página (F5) siempre se solicita [/13-router/], que existe. Este es el enfoque más simple cuando el servidor no conoce las rutas del cliente, que es el caso del servidor de [Vite], que sirve veinte ejemplos a la vez. El caso de estudio usará [createWebHistory] y direcciones “limpias” ([/schedule]), lo que requiere un pequeño esfuerzo adicional por parte del servidor.

El “armazón” de la aplicación:

<!--
  =========================================================================
  13-router/src/App.vue - el "cascarón" de la aplicación
  -------------------------------------------------------------------------
    - <RouterLink to="...">: un enlace interno. Produce una etiqueta <a>,
      pero un clic no recarga la página: es el enrutador quien actúa.
      El enlace de la página mostrada recibe la clase "router-link-active"
      (aquí reemplazada por "active", la de Bootstrap);
    - <RouterView />: el lugar donde se muestra el componente de la ruta
      actual.
  =========================================================================
-->
<script setup lang="ts">
import { RouterLink, RouterView, useRoute } from 'vue-router';

// useRoute(): la ruta actual (path, parámetros, query...), reactiva
const route = useRoute();
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 13 - the router</h1>
    <nav class="nav nav-pills mb-3">
      <RouterLink class="nav-link" active-class="active" to="/">Home</RouterLink>
      <!-- to puede ser un objeto: el NOMBRE de la ruta en lugar de su path -->
      <RouterLink class="nav-link" active-class="active" :to="{ name: 'doctors' }">Doctors</RouterLink>
      <RouterLink class="nav-link" active-class="active" :to="{ name: 'search', query: { q: 'general practitioner' } }">Search</RouterLink>
      <RouterLink class="nav-link" to="/physicians">/physicians (redirection)</RouterLink>
      <RouterLink class="nav-link" to="/unknown-page">Broken link</RouterLink>
    </nav>
    <p class="small text-muted">current route: <code>{{ route.fullPath }}</code> (name: {{ String(route.name) }})</p>
    <div class="card p-3">
      <RouterView />
    </div>
  </div>
</template>
  • línea 17: la ruta actual (ruta de acceso, parámetros, [query]...), que es dinámica: la plantilla se actualiza cuando cambia;
  • línea 24: [<RouterLink>] genera una etiqueta [<a>], pero al hacer clic no se recarga la página: el enrutador cambia la dirección y el componente mostrado. Al enlace de la página actual se le asigna la clase indicada por [active-class] (aquí, [active], que es la clase de [Bootstrap]);
  • línea 26: el destino puede ser un objeto: el nombre de la ruta en lugar de su ruta de acceso;
  • línea 27: un enlace con parámetros de consulta: [/search?q=general practitioner];
  • línea 33: el lugar donde se muestra el componente de la ruta actual.

Las páginas. La lista de médicos genera enlaces con parámetros:

<!-- 13-router/src/views/DoctorList.vue - enlaces con un parámetro -->
<script setup lang="ts">
import { RouterLink } from 'vue-router';
import { DOCTORS } from '../data';
</script>

<template>
  <ul class="mb-0">
    <li v-for="m in DOCTORS" :key="m.id">
      <!-- { name, params }: el enrutador construye por sí mismo la dirección /doctors/2 -->
      <RouterLink :to="{ name: 'doctor', params: { id: m.id } }">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</RouterLink>
    </li>
  </ul>
</template>
  • línea 11: el propio enrutador construye la dirección [/doctors/2] a partir del nombre de la ruta y de sus parámetros.

La página de un médico:

<!--
  13-router/src/views/DoctorDetail.vue - una página con un parámetro
  El id llega como una PROP (props: true en router.ts), como cadena.
  useRouter() da el propio enrutador, para navegar POR CÓDIGO.
-->
<script setup lang="ts">
import { computed } from 'vue';
import { useRouter } from 'vue-router';
import { DOCTORS } from '../data';

const props = defineProps<{ id: string }>();
const router = useRouter();

// computed: al pasar de /doctors/1 a /doctors/2, Vue REUTILIZA el
// mismo componente y solo cambia la prop - el computed lo sigue
const doctor = computed(() => DOCTORS.find((m) => m.id === Number(props.id)) ?? null);
const next = computed(() => (Number(props.id) % DOCTORS.length) + 1);
</script>

<template>
  <div v-if="doctor">
    <h2 class="h5">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</h2>
    <p>Specialty: {{ doctor.specialty }}</p>
    <div class="d-flex gap-2">
      <!-- navegación por código: router.push(...) o router.back() -->
      <button class="btn btn-sm btn-outline-secondary" @click="router.back()">Back</button>
      <button class="btn btn-sm btn-outline-primary" @click="router.push({ name: 'doctor', params: { id: next } })">Next doctor</button>
    </div>
  </div>
  <p v-else class="text-danger mb-0">Doctor no. {{ id }} does not exist.</p>
</template>
  • Línea 11: el parámetro [:id] se pasa como prop, en forma de cadena;
  • línea 12: el propio enrutador, para navegar desde el código;
  • línea 16: pasar de [/doctors/1] a [/doctors/2] no vuelve a crear el componente: [Vue.js] reutiliza el que está mostrado y solo cambia su prop. Un [computed] sigue este cambio; en cambio, el código colocado en [onMounted] se ejecutaría una sola vez;
  • líneas 26 y 27: volver a la página anterior, ir a otra página.

Image

La búsqueda es una página descrita íntegramente por su URL, igual que el formulario GET del curso [NestJS]:

<!--
  13-router/src/views/Search.vue - una página dirigida por el QUERY de 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 en marcadores, recargar y navegar hacia atrás.
-->
<script setup lang="ts">
import { computed, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { DOCTORS } from '../data';

const route = useRoute();
const router = useRouter();

// el campo de entrada comienza con el valor de la URL...
const input = ref(String(route.query.q ?? ''));
// ... y sigue a la URL si esta cambia (botón Atrás, por ejemplo)
watch(() => route.query.q, (q) => (input.value = String(q ?? '')));

const results = computed(() => {
  const q = String(route.query.q ?? '').toLowerCase();
  return DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q));
});

function search(): void {
  // cambiamos la URL; la visualización sigue a la URL (computed de arriba)
  router.push({ name: 'search', query: { q: input.value } });
}
</script>

<template>
  <form class="d-flex gap-2 mb-3" @submit.prevent="search">
    <input v-model="input" class="form-control" placeholder="name or specialty">
    <button class="btn btn-primary">Search</button>
  </form>
  <ul class="mb-0">
    <li v-for="m in results" :key="m.id">{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</li>
  </ul>
</template>
  • línea 16: [route.query] contiene los parámetros de la URL ([?q=...]);
  • línea 18: si la URL cambia (botón Anterior), el campo la sigue;
  • línea 20: los resultados dependen de la URL, no del campo;
  • línea 27: al buscar se cambia la URL; la visualización se actualiza en consecuencia. Se puede guardar la búsqueda como marcador, recargarla o retroceder.

Image

4.2. Ejemplo 14: restricciones de navegación

Algunas páginas exigen haber iniciado sesión, mientras que otras requieren un rol específico. Este ejemplo simula un inicio de sesión sin servidor:

// =========================================================================
// 14-guards/src/session.ts - una sesión SIMULADA (sin servidor)
// -------------------------------------------------------------------------
// El usuario conectado, en un ref declarado a nivel de MÓDULO: todos
// los archivos que importan este módulo comparten el mismo. (El ejemplo 15 hará
// lo mismo, mejor, con Pinia; el ejemplo 18 con un servidor real.)
// =========================================================================

import { ref } from 'vue';

export type Role = 'ADMIN' | 'DOCTOR' | 'USER';

export interface User {
  login: string;
  role: Role;
}

export const user = ref<User | null>(null);

// tres cuentas "fijas en el código" (contraseña = login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };

export function logIn(login: string, password: string): boolean {
  const role = ACCOUNTS[login];
  if (role === undefined || password !== login) {
    return false;
  }
  user.value = { login, role };
  return true;
}

export function logOut(): void {
  user.value = null;
}
  • Línea 18: un [ref] declarado en el nivel de módulo: todos los archivos que importan [session.ts] comparten el mismo;

Las rutas y sus guardias:

// =========================================================================
// 14-guards/src/router.ts - rutas PROTEGIDAS
// -------------------------------------------------------------------------
// meta: información libre adjunta a una ruta. Aquí:
//   - meta.requiresLogin: la página requiere haber iniciado sesión;
//   - meta.roles        : los roles autorizados (ausente = todos).
//
// router.beforeEach(...): una GUARDIA DE NAVEGACIÓN, ejecutada antes de CADA
// cambio de página. Devuelve:
//   - true                : la navegación continúa;
//   - otra dirección     : redirección;
// Es el equivalente en el cliente de los guardias de NestJS (JwtAuthGuard,
// RolesGuard) - con una diferencia FUNDAMENTAL: una guardia del cliente es
// solo una comodidad. El código del cliente está en manos del usuario, que
// puede modificarlo a voluntad. La protección real de los datos sigue siendo
// la del SERVIDOR (vea el capítulo sobre la caja negra).
// =========================================================================

import { createRouter, createWebHashHistory } from 'vue-router';
import { user, type Role } from './session';
import Home from './views/Home.vue';
import Login from './views/Login.vue';
import Schedule from './views/Schedule.vue';

// declaramos a TypeScript las propiedades meta que usamos
declare module 'vue-router' {
  interface RouteMeta {
    requiresLogin?: boolean;
    roles?: Role[];
  }
}

export const router = createRouter({
  history: createWebHashHistory(),
  routes: [
    { path: '/', component: Home },
    { path: '/login', component: Login },
    { path: '/schedule', component: Schedule, meta: { requiresLogin: true } },
    {
      path: '/administration',
      // Carga DIFERIDA: el código de este componente solo se descarga
      // en la primera visita de la página (Vite genera un archivo aparte para él)
      component: () => import('./views/Administration.vue'),
      meta: { requiresLogin: true, roles: ['ADMIN'] },
    },
  ],
});

router.beforeEach((to) => {
  if (to.meta.requiresLogin && user.value === null) {
    // sin sesión iniciada: a la página de inicio de sesión, recordando adónde queríamos ir
    return { path: '/login', query: { redirect: to.fullPath } };
  }
  if (to.meta.roles && user.value && !to.meta.roles.includes(user.value.role)) {
    // con sesión iniciada, pero sin el rol adecuado: de vuelta a la página de inicio, con un motivo
    return { path: '/', query: { denied: to.fullPath } };
  }
  return true;
});
  • Líneas 26–31: declaramos en [TypeScript] las propiedades que almacenaremos en el campo [meta] de las rutas. [meta] acepta datos arbitrarios; declarar estas propiedades permite usarlas sin conversión de tipos;
  • línea 38: la página requiere que el usuario haya iniciado sesión;
  • línea 43: carga diferida: el código de este componente se descarga solo en la primera visita a la página. [Vite] lo almacena en un archivo aparte. De este modo, una aplicación carga al inicio solo lo que necesita;
  • Líneas 49–59: una guardia de navegación, que se ejecuta antes de CADA cambio de página. Devuelve [true] para permitir el acceso, o bien otra dirección a la cual redirigir:
    • sin sesión iniciada: redirige a [/login], conservando la página solicitada en el parámetro [redirect];
    • con sesión iniciada pero sin el rol adecuado: vuelve a la página de inicio, con el motivo de la denegación.

La página de inicio de sesión redirige al usuario adonde quería ir:

<!--
  14-guards/src/views/Login.vue
  Después de iniciar sesión, el usuario es enviado de vuelta a la página que quería
  abrir (parámetro ?redirect=... establecido por el guard), o a la página de inicio.
-->
<script setup lang="ts">
import { ref } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { logIn } from '../session';

const route = useRoute();
const router = useRouter();
const login = ref('');
const password = ref('');
const error = ref(false);

function submit(): void {
  error.value = !logIn(login.value.trim(), password.value);
  if (!error.value) {
    const redirect = route.query.redirect;
    // solo se acepta una ruta INTERNA: comienza con /, pero no con //
    // (//site.com/... designa OTRO sitio) - ninguna redirección a otro sitio
    const internal = typeof redirect === 'string' && redirect.startsWith('/') && !redirect.startsWith('//');
    router.push(internal ? redirect : '/');
  }
}
</script>

<template>
  <p v-if="route.query.redirect" class="alert alert-warning">Log in to open {{ route.query.redirect }}.</p>
  <form class="d-flex flex-wrap gap-2" @submit.prevent="submit">
    <input v-model="login" class="form-control w-auto" placeholder="login" autocomplete="username">
    <input v-model="password" type="password" class="form-control w-auto" placeholder="password" autocomplete="current-password">
    <button class="btn btn-primary">Log in</button>
  </form>
  <p v-if="error" class="text-danger mt-2 mb-0">Incorrect login or password.</p>
</template>
  • Línea 23: solo se acepta una ruta INTERNA: comienza con [/], pero no con [//] ([//site.com/...] hace referencia a OTRO sitio). Redirigir a una URL completa recibida en la URL permitiría que un enlace malicioso envíe al usuario, inmediatamente después de iniciar sesión, a otro sitio que imite el nuestro (una vulnerabilidad conocida como [open redirect]).

Los demás archivos son muy cortos:

<script setup lang="ts">
import { RouterLink, RouterView, useRouter } from 'vue-router';
import { logOut, user } from './session';

const router = useRouter();

function onLogOut(): void {
  logOut();
  router.push('/');
}
</script>

<template>
  <div class="container py-4" style="max-width: 720px">
    <h1 class="h3 mb-3">Example 14 - navigation guards</h1>
    <nav class="d-flex gap-3 align-items-center mb-3">
      <RouterLink to="/">Home</RouterLink>
      <RouterLink to="/schedule">Schedule (logged in)</RouterLink>
      <RouterLink to="/administration">Administration (ADMIN)</RouterLink>
      <span class="ms-auto">
        <template v-if="user">
          {{ user.login }} <span class="badge text-bg-primary">{{ user.role }}</span>
          <button class="btn btn-sm btn-link" @click="onLogOut">log out</button>
        </template>
        <RouterLink v-else to="/login">log in</RouterLink>
      </span>
    </nav>
    <div class="card p-3"><RouterView /></div>
  </div>
</template>
<script setup lang="ts">
import { useRoute } from 'vue-router';
const route = useRoute();
</script>

<template>
  <!-- ?denied=...: lo establece la guardia cuando el rol no corresponde -->
  <p v-if="route.query.denied" class="alert alert-danger">Your role does not allow you to open {{ route.query.denied }}.</p>
  <p class="mb-0">Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).</p>
</template>

Al hacer clic en “Administración (ADMIN)” sin haber iniciado sesión, se llega a la página de inicio de sesión:

Image

Con la sesión iniciada con la cuenta [martin] (rol [USER]), la guardia deniega el acceso a la página de administración:

Image

Una nota FUNDAMENTAL: una guardia de navegación es solo una comodidad (para evitar mostrar una página innecesaria). El código del lado del cliente está en manos del usuario; puede leerlo y modificarlo en su navegador. La verdadera protección de los datos proviene del servidor, que verifica la identidad y el rol del usuario en cada solicitud. Lo veremos con el servidor [RdvMedecins].