6. Capítulo 5 - El cliente [Vue.js] de la aplicación [RdvMedecins]
Este capítulo detalla, archivo por archivo, el contenido de la carpeta [rdvmedecins-vuejs-client] que se incluye con este documento, con el formato adoptado en todo este curso: código fuente numerado línea por línea, seguido de una sección titulada “Comentemos este código:”. Cada carpeta de proyecto contiene además su propio [README.md].
6.1. Visión general de la arquitectura
Como en el documento original, y como en las variantes [Angular] y [React] de este curso, el cliente sigue una arquitectura en capas, que aquí llamaremos V-Services (Vista-Servicios).
Conviene señalar una diferencia de terminología: en AngularJS 1.x, la Vista (la plantilla HTML) y el Controlador (la clase JavaScript asociada) eran dos entidades distintas, vinculadas por el $scope. En [Vue.js], se combinan en una sola entidad, el componente [.vue] (véase el capítulo anterior), exactamente como en [Angular] y [React], aunque la forma difiere (un archivo con tres bloques en lugar de una clase o una función); por eso, en lo que sigue, hablaremos simplemente de “componentes” donde el documento original distinguía entre vista y controlador.
Como en el documento original, los componentes NUNCA se comunican directamente por HTTP: este papel está reservado exclusivamente a la capa de Servicios (en este caso, el composable [useAppointmentService()] y el composable [useAuth()]). Es un principio de diseño que se aplica por igual a AngularJS 1.x, [Angular], [React] o [Vue.js]; no ha cambiado.
6.2. Estructura del proyecto
Esta estructura sigue directamente el flujo del documento original (inicio de sesión, selección de médico/fecha, consulta de la agenda, reserva de una cita), organizado aquí simplemente en componentes [Vue.js] en lugar de controladores/vistas separados de AngularJS 1.x, componentes standalone ([Angular]) o componentes funcionales ([React]). En comparación con las otras dos variantes de este curso:
- el componente raíz cabe en un solo archivo (App.vue, además de README.md) en lugar de tres ([Angular]: app.ts/app.html/app.css) o de tres también en el lado de [React] (App.tsx/App.css/README.md): [<template>] y [<script setup>] fusionan, dentro del mismo archivo, lo que [JSX] ya había fusionado en el lado de [React]; y App.vue, como App.tsx, no tiene un archivo de configuración de la aplicación equivalente a app.config.ts;
- Aparece una carpeta `core/composables/` en lugar de `core/context/` del lado de [React] (que a su vez está ausente en el lado de [Angular]): contiene los composables que actúan como servicios inyectables ([SettingsService], [AuthService], [LanguageService]) para la variante [Angular]; este mecanismo (composables + [provide]/[inject]) se presentó en el capítulo anterior, junto con un ejemplo genérico (véase el capítulo anterior, “Lógica compartida”).
[Bootstrap] 5 se utiliza en todas las vistas (se importa en main.ts; véase más abajo): una evolución directa de Bootstrap 3, que ya usaba el documento original, sin cambios respecto a las variantes [Angular] y [React] de este curso.
6.3. Archivos de configuración del proyecto
6.3.1. package.json
Comentemos este código:
- Líneas 5–8: ["scripts": { … }] — los comandos [npm run <name>] disponibles. [start] (igual que dev) inicia el servidor de desarrollo de [Vite] con recarga automática cada vez que se modifica un archivo fuente, en el puerto 4200 (véase vite.config.ts más abajo), el mismo puerto que las variantes [Angular] y [React] de este curso;
- Línea 7: ["build": "vue-tsc -b && vite build",] — diferencia notable con [React] ([tsc -b && vite build]): [vue-tsc] reemplaza al compilador estándar de TypeScript por una variante capaz de verificar también los tipos DENTRO de [<template>] (por ejemplo, un [v-model] sobre una propiedad inexistente, o un [:doctors] que no coincide con el tipo esperado por [defineProps]), de forma muy parecida a lo que hace [Angular] con su opción strictTemplates, mientras que [React] simplemente verifica el [JSX] como cualquier otro TypeScript;
- Líneas 12–16: ["dependencies": { … }] — los paquetes necesarios para la ejecución en el navegador: [vue] (el núcleo del framework), [vue-i18n] (traducción FR/EN; véase más abajo), [bootstrap] (solo la hoja de estilos). A diferencia de las variantes [Angular] y [React] de este curso, no hay un equivalente separado de [@angular/router]/[react-i18next] (vue-i18n incorpora su motor directamente; véase i18n.ts) ni de RxJS;
- líneas 17–23: ["devDependencies": { … }] — paquetes necesarios únicamente durante el desarrollo: [@vitejs/plugin-vue] (conversión de los archivos [.vue] a JavaScript y recarga en caliente), TypeScript, [vue-tsc] (véase arriba) y [Vite] en sí. A diferencia de [React] ([@types/react], [@types/react-dom]), [Vue.js] no requiere paquetes de tipos separados: la propia biblioteca está escrita en TypeScript.
A diferencia del servidor [NestJS] (módulo [commonjs], véase el Capítulo 3), este proyecto se ejecuta como módulos ECMAScript nativos (import/export), exactamente igual que las variantes [Angular] y [React] de este curso.
6.3.2. vite.config.ts
Comentemos este código:
- línea 5: [plugins: [vue()],] — habilita la transformación de los archivos [.vue] (separación de los tres bloques, compilación de [<template>] según el modo de renderizado) y la recarga en caliente; el equivalente, para [Vue.js], de lo que hacía [@vitejs/plugin-react]() para [JSX] en el lado de [React] (véase el capítulo anterior) y de lo que hace [@angular/build:dev-server] por [Angular] en segundo plano;
- líneas 6–8: [server: { port: 4200, },] — fija el puerto del servidor de desarrollo en 4200, igual que [ng serve] en el lado de [Angular] y que el cliente [React] de este curso: una decisión puramente didáctica, para que las tres variantes de este curso sigan siendo intercambiables sin cambiar su forma de trabajo.
Este archivo no tiene equivalente en el proyecto AngularJS 1.x original; en el lado de [Angular] de este curso, cumple esta función [angular.json] ; en el lado de [NestJS] (Capítulo 3), es [nest-cli.json].
6.3.3. tsconfig.json
Analicemos este código:
- línea 15: ["strict": true,] — como el [tsconfig.json] de las variantes [Angular] y [React] de este curso, el modo estricto completo de TypeScript está activo: cada variable debe tener un tipo determinable y cada valor null o undefined debe tratarse explícitamente;
- líneas 18–19: ["noUnusedLocals": true, "noUnusedParameters": true,] — señala durante la compilación toda variable o parámetro declarado pero nunca utilizado; la misma configuración que en [React];
- Línea 13: ["noEmit": true] — aquí TypeScript se utiliza solo para la VERIFICACIÓN de tipos ([npm run build] lanza primero [vue-tsc -b], que falla si se produce un error de tipos, incluso dentro de un [<template>]; véase package.json más arriba): es [Vite] (mediante esbuild) quien produce realmente el JavaScript que ejecuta el navegador.
A diferencia del archivo [tsconfig.json] generado a partir de [React] ([jsx: ‘react-jsx’]), este archivo no contiene ninguna configuración específica del framework: es [vue-tsc] (y no el compilador estándar de TypeScript) quien determina de antemano cómo analizar un archivo [.vue], un mecanismo independiente de este archivo de configuración, a diferencia de [React], donde la compatibilidad con [JSX] se configura directamente aquí.
6.4. Inicio de la aplicación
6.4.1. index.html
Comentemos este código:
- línea 2: [<html lang="en">] — igual que en [Angular] y [React], dado que esta página HTML es estática (el navegador la carga ANTES de que se inicie la aplicación [Vue.js]), no puede reflejar de inmediato una selección de idioma hecha posteriormente por el usuario;
- línea 10: [<div id="app"></div>] — el único elemento que contiene esta página inicialmente, y que [Vue.js] llena por completo una vez montado (véase main.ts más abajo); el equivalente exacto de <app-root></app-root> en el lado de [Angular], de <div id="root"></div> en el lado de [React] y de [ng-app="rdvmedecinsApp"] en la etiqueta <html> del documento original (AngularJS 1.x, 2014); solo cambia el identificador (convención de [Vue.js]: "app");
- línea 11: [<script type="module" src="/src/main.ts"></script>] — como en [React], es index.html quien hace referencia directamente a main.ts (una convención propia de [Vite]), y no al revés. En desarrollo, [Vite] transforma y sirve este archivo sobre la marcha; en producción ([npm run build]), por supuesto, se compila de antemano.
Como en las otras dos variantes, solo hay un punto de entrada para toda la aplicación: esta es la definición misma de una aplicación web de página única (SPA), tal como ya se describió en el documento original.
6.4.2. src/main.ts
Comentemos este código:
- línea 12: [const app = createApp(App);] — el equivalente directo de [bootstrapApplication(App, appConfig)] en el lado de [Angular] y de [createRoot(...).render(...)] en el lado de [React]: [createApp(...)] crea una instancia de la aplicación (pero aún no la monta; véase la línea 30);
- línea 14: [app.use(i18n);] — instala el plugin [vue-i18n]: a partir de ahora, se puede usar [useI18n()] en el [<script setup>] de cualquier componente;
- líneas 16–23: [const settingsStore = createSettingsStore(); app.provide(SettingsKey, settingsStore); …] — los tres [createXxxStore()] + [app.provide(...)] de core/composables/ (véase más abajo) hacen que [useSettings()], [useAuth()] y [useLanguage()] se puedan usar desde cualquier componente descendiente; el equivalente de los tres [provideXxx()] de [app.config.ts] en el lado de [Angular] ([providers: [...]]), pero expresado aquí como una SECUENCIA de llamadas a funciones en lugar de como un arreglo de proveedores o, en el lado de [React], como un ANIDAMIENTO de componentes [Provider] que rodean al componente raíz; aquí no es necesario ningún anidamiento visual, a diferencia de [React] (compárese con main.tsx del cliente React de este curso: <SettingsProvider><AuthProvider>...) ;
- líneas 16, 19: [const settingsStore = … const authStore = createAuthStore(settingsStore);] — el ORDEN de las llamadas importa: [createAuthStore(...)] requiere que [settingsStore] ya exista (para leer [apiBaseUrl]); por eso se le pasa directamente como parámetro, en lugar de mediante una inyección de [Vue.js]: en esta etapa todavía no existe ningún componente, de modo que [inject()] no serviría de nada;
- línea 22: [const languageStore = createLanguageStore();] — se llama DESPUÉS de [app.use(i18n)] (línea 14): este composable requiere que el plugin [vue-i18n] ya esté instalado;
- línea 30: [app.mount(container);] — monta realmente la aplicación en el elemento #app de index.html; separado de [createApp(App)] (línea 12) precisamente para dar tiempo a que las líneas intermedias (app.use, app.provide) configuren la aplicación antes de mostrarla.
Como los clientes [Angular] y [React] de este curso (una sola página, sin tabla de rutas), este cliente, [Vue.js], NO utiliza enrutador: App.vue muestra la pantalla de inicio de sesión o el resto de la aplicación, según [useAuth().isLoggedIn]; basta con un simple [v-if] ; un enrutador ([vue-router] u otro) no habría aportado ningún valor a una aplicación de página única.
6.4.3. src/i18n.ts
Comentemos este código:
- línea 8: [legacy: false,] — habilita el modo “API de composición” de [vue-i18n]: [useI18n()] en los componentes (como [useTranslation()] en el lado de [React]), en lugar de [this.$t] (el modo antiguo, pensado para la API de opciones de [Vue.js] 2);
- líneas 9–11: [locale: navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en', fallbackLocale: 'en', messages: {},] — idioma de inicio (francés si el idioma del navegador empieza con 'fr', inglés en caso contrario), idioma de respaldo (inglés) si falta una clave en el diccionario actual, y diccionarios vacíos al inicio; [language.composable.ts] (véase más abajo) reemplaza de inmediato [locale] por la selección almacenada en localStorage, si existe;
- líneas 14–22: [export async function loadDictionary(language: Language): Promise<void> { …] — a diferencia de [i18next-http-backend] (React) o de [TranslateHttpLoader] (Angular), [vue-i18n] NO ofrece de forma nativa un “cargador”: simplemente espera que se le suministren los diccionarios ya cargados, mediante [setLocaleMessage(...)]. Esta función reconstruye entonces manualmente lo que [HttpBackend] hacía automáticamente en el lado de [React]: utiliza [fetch] para recuperar el archivo [/i18n/<language>.json] (EXACTAMENTE la misma URL que las otras dos variantes de este curso) y luego guarda su contenido en [vue-i18n];
- líneas 15–17: [if (loadedDictionaries.has(language)) { return; }] — evita volver a descargar un idioma que ya se encontró durante la sesión; la misma optimización que el almacenamiento en caché interno de [i18next-http-backend] en el lado de [React].
6.4.4. src/index.css
Comentemos este código:
- línea 1: [body { background-color: #f5f7fa; }] — idéntico a las otras dos variantes: un gris muy claro en lugar del blanco puro por defecto, para que las tarjetas de [Bootstrap] (fondo blanco, .card) se destaquen ligeramente del fondo de la página;
- líneas 5–11: [.free-slot { cursor: pointer; } .free-slot:hover { … }] — se aplica a las filas de la tabla de la agenda que representan una franja horaria disponible (véase Schedule.vue, [:class="scheduleSlot.appointment === null ? ‘free-slot’ : undefined"] más abajo): el cursor adopta la forma de una mano en toda la fila, y el fondo se vuelve ligeramente verde al pasar el mouse; aquí, a diferencia del cliente [React] de este curso (donde el cursor “pointer” se aplicaba al propio botón “Book”), toda la fila de la tabla es en la que se puede hacer clic, como se pretendía en el documento original.
Este archivo contiene estilos globales, a diferencia de los estilos “locales” que un componente [Vue.js] puede definir dentro de su propio bloque [<style scoped>] (no se utiliza en este proyecto: [Bootstrap] e index.css bastan para todo lo que implementa este documento); el mismo principio que en [Angular] y [React] (archivos de estilo separados por componente).
6.5. La capa core/models
6.5.1. src/app/core/models/appointment.models.ts
Comentemos este código:
- Las interfaces en sí son una copia ESTRICTA de las variantes [Angular] y [React] de este curso (simplemente reescritas, como todo el cliente): las interfaces de TypeScript que describen los datos intercambiados con el servidor no dependen de ningún framework; es TypeScript “puro”, que corresponde exactamente a la clase [ServerResponse]<T> y a las entidades [TypeORM] del servidor [NestJS] (Capítulo 3);
- [Role]/[LoginResult]: copias exactas de los tipos del servidor del mismo nombre (src/entities/user.entity.ts, auth/login-result.model.ts, Capítulo 3).
En AngularJS 1.x (2014), el JavaScript puro no permitía describir de esta manera el formato de datos esperado. Con TypeScript, utilizado por las tres variantes de este curso, un error tipográfico en el nombre de un campo se señala incluso antes de ejecutar el programa, directamente en tiempo de compilación.
6.6. La capa core/composables
En este cliente [Vue.js], este directorio desempeña el mismo papel que core/context/ en el cliente [React] de este curso (véase el capítulo anterior, “Compartir la lógica”): agrupa los tres composables que sirven, en este caso, como servicios inyectables ([SettingsService], [AuthService] y una parte de [LanguageService]) del lado de [Angular].
6.6.1. src/app/core/composables/settings.composable.ts
Comentemos este código:
- línea 8: [export const SettingsKey: InjectionKey<SettingsStore> = Symbol('SettingsStore');] : la clave de inyección (véase el capítulo anterior), un [Symbol] tipado en lugar de una simple cadena;
- líneas 10–18: [export function createSettingsStore(): SettingsStore { …] : reemplaza exactamente a [readonly apiBaseUrl = signal(‘http://localhost:8080’);] de [SettingsService] del lado de [Angular]: el mismo valor predeterminado, con la misma posibilidad de modificarlo mediante el campo “Server URL” de la vista de inicio del documento original; aquí se elige [reactive(...)] (en lugar de [ref()]) porque el store incluye VARIAS propiedades (apiBaseUrl y su función de actualización); [store.apiBaseUrl] se lee y se escribe directamente, sin [.value];
- líneas 20–26: [export function useSettings(): SettingsStore { …] : el composable al que llaman los componentes ([const settings = useSettings();]), equivalente directo de [inject(SettingsService)] del lado de [Angular] y de [useSettings()] del lado de [React].
6.6.2. src/app/core/composables/auth.composable.ts
Port de [AuthService]: gestiona el inicio de sesión del usuario, llama a [POST /login], almacena el token JWT recibido (y la identidad y el rol que lo acompañan) y garantiza que sobreviva a una recarga de la página mediante [localStorage]. Es el único lugar de la aplicación que, junto con [core/services/appointment.service.ts] (véase más adelante), se comunica con el servidor mediante HTTP.
Analicemos este código:
- líneas 14–21: [function readStoredSession(): StoredSession | null { …] : protegida por un bloque try/catch, igual que en [Angular] y [React]: [localStorage] puede no estar disponible (navegación privada muy restrictiva) o contener un valor dañado; en ese caso, simplemente se supone que no hay sesión;
- línea 37: [const initialSession = readStoredSession();] : se llama una sola vez, cuando se construye el store (en src/main.ts), exactamente el mismo papel que desempeña el inicializador [useState(readStoredSession)] del lado de [React] o [signal(readStoredSession())] del lado de [Angular]. Si el usuario recarga la página después de iniciar sesión, sigue con la sesión iniciada;
- líneas 39–51: [function applySession(session: StoredSession | null): void { …]: extrae lo que [logIn()] y [logOut()] tienen en común: actualizar las propiedades reactivas del store Y sincronizar [localStorage] en un solo paso; es una pequeña función interna, ausente de la versión equivalente de [React] (que repetía esta lógica en cada una de las dos funciones, por no existir un punto de escritura común igual de natural);
- líneas 53–79: [const store = reactive<AuthStore>({ … });] : mismo principio que settings.composable.ts: un único objeto [reactive] cuyas propiedades (isLoggedIn, login, accessToken…) son modificadas EN SU LUGAR por [applySession()] en vez de ser reemplazadas por un nuevo objeto, a diferencia de [AuthContext] del lado de [React], que debe reconstruir un nuevo objeto [value] mediante [useMemo]() en cada cambio (véase el capítulo anterior); [Vue.js] no necesita hacerlo aquí: solo los componentes que leen una propiedad que realmente ha cambiado se vuelven a dibujar automáticamente;
- líneas 61–74: [async logIn(login: string, password: string): Promise<LoginResult> { …] : equivale a: POST /login, cuerpo JSON { login, password }; como del lado de [React] (fetch/async-await), los pasos fluyen de forma natural de arriba abajo, sin un operador RxJS específico (a diferencia de [AuthService.logIn()] del lado de [Angular], que devuelve un Observable y guarda la sesión en un operador tap() separado);
- líneas 76–78: [logOut(): void { applySession(null); },] : puramente local (sin llamada al servidor): en este port, un token JWT no se “revoca” en el servidor; expira por sí solo después de JWT_EXPIRES_IN (véase el .env del servidor, Capítulo 3).
6.6.3. src/app/core/composables/language.composable.ts
Port de una parte de [LanguageService]: centraliza el cambio de idioma de la interfaz (francés/inglés) sobre [vue-i18n] (véase i18n.ts más arriba).
Comentemos este código:
- Línea 15: [currentLanguage: i18n.global.locale.value as Language,] : [vue-i18n] ya expone su idioma actual como un [ref] reactivo ([i18n.global.locale]); [LanguageStore] no crea un estado aparte, simplemente lo REPUBLICA con un nombre estable (currentLanguage), exactamente el mismo concepto que en [Angular], donde [LanguageService] simplemente republicaba [this.translate.currentLang] con otro nombre;
- líneas 22–27: [function applyLanguage(language: Language): void { …] : [loadDictionary(language)] (véase i18n.ts) recupera, si es necesario, el diccionario correspondiente Y LUEGO, una vez resuelto, se cambia a [i18n.global.locale.value], a diferencia de [i18n.changeLanguage(...)] del lado de [React] (que hace ambas cosas a la vez); aquí, como [vue-i18n] no tiene un “cargador” integrado (véase i18n.ts), este composable orquesta él mismo los dos pasos;
- líneas 29–31: [watch(i18n.global.locale, (newLanguage) => { store.currentLanguage = newLanguage as Language; });] : [watch(source, callback)] vuelve a ejecutar el callback cada vez que cambia el valor observado; es el equivalente, para una sola propiedad, de [useEffect](..., [dep]) del lado de [React] o de [effect()] del lado de [Angular]. Esta línea es la que realiza efectivamente la “republicación” mencionada al comienzo de este archivo: [store.currentLanguage] permanece SIEMPRE sincronizado con [i18n.global.locale], sin importar cómo haya cambiado este último;
- líneas 33–38: [const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null; …] : en la primera carga: si el usuario ya había elegido un idioma en una visita anterior, se restaura; de lo contrario, se mantiene el idioma de arranque definido en i18n.ts (inglés, o francés para un navegador en francés), pero igualmente hay que cargar SU diccionario, algo que i18n.ts no hace por sí mismo; es exactamente el papel que desempeña [useEffect](..., []) de language.context.tsx del lado de [React], ejecutado una sola vez durante la configuración.
Equivale al botón “FR / EN” del cliente AngularJS 1.x original, que en su momento se basaba en la biblioteca [angular-translate], la predecesora, dentro del ecosistema AngularJS 1.x, de [ngx-translate] ([Angular]), seguida de [i18next] ([React]) y de [vue-i18n] ([Vue.js]).
6.7. Diccionarios de traducción (public/i18n/)
[loadDictionary()] (véase i18n.ts más arriba) carga uno de estos dos archivos mediante una solicitud [HTTP GET /i18n/<language>.json] cada vez que cambia el idioma (o se usa por primera vez). [vue-i18n] resuelve luego cada clave ("LOGIN.TITLE", "SCHEDULE.FREE"…) mediante el hook [useI18n() (function t(...))] que se utiliza en todos los componentes del directorio features/ (véase más adelante en este capítulo).
6.7.1. public/i18n/fr.json
Comentemos este código:
- Este archivo refleja, clave por clave, los archivos de las variantes [Angular] y [React] de este curso (las mismas secciones que en DOCTOR_DAY_PICKER/SCHEDULE/BOOKING_DIALOG, que no se reproducen aquí por razones de espacio; véase el archivo proporcionado para más detalles), con dos excepciones: la línea 3 ([TITLE]), que ahora hace referencia a [Vue.js] en lugar de [React]; y cuatro claves nuevas ([DEMO_ACCOUNTS_*], líneas 14–17) que Login.vue (véase más adelante) muestra para presentar las dos cuentas de demostración directamente en la pantalla de inicio de sesión, una pequeña comodidad que no incluyen las otras dos versiones de este curso;
- Un objeto JSON anidado, con una sección por componente; [vue-i18n] lo aplana en un diccionario plano, en el que cada clave completa ("LOGIN.TITLE") se forma concatenando la ruta con puntos, exactamente como lo hace [i18next] en [React], y como lo hace [TranslateService] en [Angular].
6.7.2. public/i18n/en.json
Analicemos este código:
- línea 3: ["TITLE": "RdvMedecins - NestJS / Vue.js port",] : solo cambia el subtítulo; “[RdvMedecins]” permanece igual en ambos idiomas, pues es el nombre propio de la aplicación.
Ambos archivos deben seguir siendo estructuralmente idénticos (las mismas claves en los dos): así se garantiza que una clave exista en ambos idiomas. Las partes que NO se traducen permanecen sin cambios con respecto a las variantes [Angular] y [React] de este curso: los mensajes de error devueltos por el servidor [NestJS] siguen en inglés sea cual sea el idioma seleccionado en el cliente, y los nombres de los médicos y de los pacientes provienen directamente de la base de datos.
6.8. La capa core/interceptors
6.8.1. src/app/core/interceptors/auth.interceptor.ts
Ni [Vue.js] ni [React] tienen un interceptor HTTP integrado como [HttpClient]/[withInterceptors([...])] del lado de [Angular]. Este archivo reimplementa el mismo concepto como un composable que encapsula [fetch]: es el equivalente moderno de los interceptores $http de AngularJS 1.x que ya vimos en el documento original (capítulo “Ejemplo 6”).
Analicemos este código:
- línea 3: [export function useAuthFetch(): (path: string, options?: RequestInit) => Promise<Response> {]: a diferencia de [authInterceptor] del lado de [Angular] (una función registrada una vez por todas en [app.config.ts], que luego se aplica automáticamente a cada llamada a [HttpClient]), [useAuthFetch()] es un composable que cada invocador (aquí, [useAppointmentService()], véase más adelante) debe llamar explícitamente y utilizar en lugar de [fetch()], el mismo enfoque que del lado de [React]; a diferencia de [React] ([useCallback](...)), aquí no es necesario almacenar la función devuelta: el cuerpo de un [<script setup>] se ejecuta una sola VEZ por instancia de componente, por lo que se construye una sola vez;
- líneas 8–10: [if (auth.accessToken) { headers.set(‘Authorization’, …); }] : equivalente directo de [request.clone({ setHeaders: { Authorization: … } })] del lado de [Angular]. A diferencia de una solicitud de [HttpClient] (que es inmutable), las opciones de [fetch] son simplemente un objeto JavaScript: no es necesario crear una copia “clonada”; basta con construir el objeto [headers] antes de la llamada;
- líneas 14–16: [if (response.status === 401) { auth.logOut(); }] : mismo principio que en [Angular] (catchError + HttpErrorResponse.status === 401): un 401 durante una sesión significa que el token ya no es válido; el cliente se desconecta de forma controlada; [fetch] no rechaza su Promise por un estado HTTP de error (a diferencia de un Observable de [HttpClient]), por eso esta prueba examina directamente [response.status], sin un bloque try/catch;
- línea 18: [return response;] : la respuesta (potencialmente un 401) se devuelve de todos modos tal cual al invocador, que sigue siendo responsable de gestionar las consecuencias (véanse useAppointmentService() y extract<T>(), más adelante); el interceptor no debe ocultar el error al código que lo llama.
Se podría añadir manualmente [Authorization: Bearer ...] a cada uno de los métodos de [useAppointmentService()]. Un composable compartido evita esta repetición y ofrece el mismo beneficio que un interceptor de [Angular]: la pregunta “¿cómo se autentica una solicitud?” se responde en un único lugar.
6.9. La capa core/services
6.9.1. src/app/core/services/appointment.service.ts
Port de [AppointmentService]: la ÚNICA parte de la aplicación (junto con [core/composables/auth.composable.ts] para el inicio de sesión propiamente dicho) que se comunica con el servidor [NestJS] mediante HTTP. Es el equivalente directo del servicio [dao] presentado en el capítulo “Ejemplo 6: servicios HTTP” del documento original (que utilizaba el servicio $http de AngularJS).
Comentemos este código:
- línea 5: [async function extract<T>(httpResponse: Response): Promise<T> {] : en lugar de repetir “si status !== 0, es un error” en cada función pública, aquí se centraliza una sola vez, que es exactamente el papel de [AppointmentService.extract()] en [Angular] y de [extract<T>()] en [React];
- Línea 13: [export function useAppointmentService() {]: un composable que se lee y se usa exactamente como [inject(AppointmentService)] del lado de [Angular]: se llama una vez al comienzo del [<script setup>] de un componente y luego se utilizan las funciones que devuelve;
- líneas 17–20: [async function getAllDoctors(): Promise<Doctor[]> { …] : a diferencia de [React] ([useCallback](..., [authFetch, apiBaseUrl])), ninguna de estas funciones necesita almacenarse en caché entre renderizaciones: un [<script setup>] [Vue.js] se ejecuta una sola vez por instancia de componente (véase auth.interceptor.ts más arriba); este detalle técnico, necesario del lado de [React], desaparece por completo aquí;
- cada función corresponde exactamente a una de las once rutas del controlador [NestJS] (Capítulo 3); de hecho, los mismos nombres aparecen en ambos lados (getAllDoctors, addAppointment, deleteAppointment…), lo que facilita comparar el lado del servidor y el del cliente, igual que con [Angular] y [React].
A diferencia de [AuthStore.logIn()] (capítulo anterior), ninguno de los métodos de este composable necesita conservar datos después de la llamada: es el componente invocador (App.vue) quien decide qué hacer con el resultado (doctors.value = result, schedule.value = result…), la misma separación de responsabilidades que se vio con [Angular] y [React], donde [AppointmentService] y [useAppointmentService()] no saben nada del estado que se muestra en pantalla.
6.10. La capa features: los cuatro componentes
6.10.1. src/app/features/login/Login.vue
Port de [login.component.ts/.html] ([Angular]) y de [Login.tsx] ([React]): la pantalla de inicio de sesión, equivalente a la vista [login.html] del cliente AngularJS 1.x original (la primera vista que muestra la aplicación). Este componente no sabe nada de la agenda ni de las citas: simplemente recoge un par (usuario, contraseña), lo transmite a [AuthStore.logIn(...)] y muestra los posibles errores.
Analicemos este código:
- línea 6: [const { t } = useI18n();] : un componente standalone de [Angular] declara, en su decorador [@Component], los pipes que utiliza ([imports: [TranslatePipe]]); un componente de [Vue.js], como uno de [React], no tiene nada equivalente que declarar: [useI18n()] simplemente se importa y se llama, como cualquier otra función;
- líneas 9–12: [const login = ref(''); const password = ref(''); …] : un estado puramente local del formulario (lo que el usuario está escribiendo en ese momento), equivalente a los valores [signal()] locales del componente de [Angular] y a [useState()] del lado de [React] (aquí, un [ref] por valor en lugar de un [value, setValue] par);
- línea 33: [@submit.prevent="onSubmit"] : una diferencia deliberada con respecto a la variante de [Angular] de este curso: en lugar de escuchar (keyup.enter) en cada campo por separado, este componente utiliza un verdadero elemento <form> y su evento nativo [submit]; tanto la tecla Enter como un clic en el botón “Log in” (type="submit") activan entonces [onSubmit()]; el modificador [.prevent] impide automáticamente el comportamiento predeterminado del navegador (recargar la página), el equivalente del [event?.preventDefault()] explícito del lado del cliente, pero expresado directamente en el [<template>] en lugar de en el código TypeScript;
- líneas 44–45: [autocomplete="username" v-model="login"] : [v-model] enlaza el campo y el [login] [ref] en ambas direcciones (lectura Y escritura) en un solo atributo, una simplificación en comparación con [React] ([value={login} onChange={(e) => setLogin(e.target.value)}], dos atributos separados) y con [Angular] ([[(ngModel)]] o [[value]]+(input), según el caso);
- líneas 23–26: [catch { submitting.value = false; inútil.value = ‘LOGIN.ERROR’; }] : un par usuario/contraseña no válido hace que [logIn()] falle con una excepción JavaScript (lanzada por auth.composable.ts, véase más arriba): se muestra “LOGIN.ERROR” al usuario, sin intentar distinguir entre un nombre de usuario inexistente y una contraseña incorrecta, exactamente el mismo enfoque que en [Angular] y en [React]. Almacenar una CLAVE de traducción en lugar de un texto ya resuelto tiene la misma ventaja que en las otras dos variantes: si el usuario cambia de idioma mientras se muestra este mensaje, este se traduce solo ([t(error)], línea 37, reevaluado automáticamente).
Este componente combina en un ÚNICO archivo [.vue] lo que [Angular] separa en dos (login.component.ts para la lógica, login.component.html para la plantilla): [<template>] corresponde a la plantilla, [<script setup>] corresponde a la lógica, en el mismo archivo, exactamente como ya lo hacía [Login.tsx] del lado de [React] con el [JSX] que devuelve su función.
6.10.2. src/app/features/doctor-day-picker/DoctorDayPicker.vue
Port de [doctor-day-picker.component.ts/.html] ([Angular]) y de [DoctorDayPicker.tsx] ([React]): el componente que permite seleccionar un médico y una fecha y luego solicitar la visualización de su agenda. Conceptualmente equivalente a los ejemplos 7 a 10 del cliente AngularJS 1.x original.
Analicemos este código:
- líneas 6–8: [defineProps<{ doctors: Doctor[]; }>();] : un [input.required<Doctor[]>()] [Angular] se convierte en una PROP [Vue.js]; a diferencia de [React] (un objeto `props` desestructurado, sin una declaración de tipo aparte), [defineProps<...>()] es una función que el compilador de [Vue.js] reconoce en tiempo de compilación: ni siquiera existe ya en el JavaScript final;
- Líneas 10–12: [const emit = defineEmits<{ search: [criteria: { … }]; }>();] : un [output<...>()] [Angular] se convierte aquí en un EVENTO declarado; [App.vue] lo escuchará con [@search="onSearchSchedule"] (véase más adelante), exactamente como se suscribía al evento (search) de la plantilla de [Angular]; en cuanto a [React], era una simple función pasada como prop ([onSearch]); [Vue.js] distingue aquí de forma más explícita entre entradas y salidas, como [Angular];
- líneas 21–26: [function onSearchClick(): void { … emit(‘search’, { … }); }] : [emit(‘search’, ...)] desencadena el evento; es el equivalente directo de [search.emit(...)] del lado de [Angular] y de la llamada a la función recibida como prop ([onSearch(...)]) del lado de [React];
- línea 36: [select id="select-doctor" class="form-select" v-model="selectedDoctorId"] : [v-model] en un <select> enlaza directamente el valor seleccionado con [selectedDoctorId.value], una simplificación en comparación con [React] (:value y @change por separado, véase el capítulo anterior) y con [Angular] ([(ngModel)] o [value]+(change), según el caso);
- líneas 38–40: [option v-for="doctor in doctors" :key="doctor.id" :value="doctor.id"] : [v-for] + [:key] es el equivalente en [Vue.js] de [.map(...)] + [key={...}] del lado de [React] (y de [@for (doctor of doctors(); track doctor.id)] del lado de [Angular]): en los tres casos, un identificador estable indica cómo reconocer a un médico que ya se muestra si se vuelve a dibujar.
6.10.3. src/app/features/schedule/Schedule.vue
Port de [schedule.component.ts/.html] ([Angular]) y de [Schedule.tsx] ([React]): muestra la agenda de un médico para un día determinado. Equivale a los ejemplos 8 y 9 del cliente AngularJS 1.x original. Desde que se añadió la autenticación, este componente también recibe [canEdit]: cuando vale false (rol USER), los botones “Book”/“Cancel” desaparecen; la agenda sigue siendo visible, pero en modo de solo lectura.
Comentemos este código:
- líneas 34, 36: [p v-if="schedule === null" … div v-else …] : [v-if]/[v-else] reemplazan el “retorno anticipado” (early return) utilizado en [React] ([if (schedule === null) return <p>...</p>;]): mientras no se haya realizado ninguna búsqueda (o la agenda esté vacía), solo se incluye en el DOM el mensaje de estado vacío, sin siquiera construir la tabla que sigue;
- línea 7: [canEdit: boolean;] : una novedad introducida por la autenticación, similar a [Angular] y a [React]: App.vue le envía [auth.isAdmin] (véase más adelante). Cuando vale false (rol USER), el botón “Book”/“Cancel” ni siquiera existe en el DOM (línea 67, [v-if="canEdit"]); no está simplemente atenuado o deshabilitado, sino totalmente ausente;
- Líneas 58–64: [span v-if="scheduleSlot.appointment === null" … span v-else …] : [v-if]/[v-else] reemplazan el operador ternario utilizado del lado de [React]: una insignia [Bootstrap] verde (“Free”) o gris (nombre del paciente), según el estado del horario;
- línea 67: [button v-if="canEdit" type="button"] : a diferencia de [React] (el operador [&&], {canEdit && (…)}), [v-if] basta por sí solo aquí en [Vue.js]: no existe un equivalente en [Vue.js] de [&&] para “mostrar solo si es verdadero, y de lo contrario nada”; [v-if] hace exactamente eso por sí solo;
- línea 70: [{{ scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT') }}] : como del lado de [Angular] (donde se puede usar un pipe en cualquier expresión de la plantilla) y del lado de [React], [t(...)] es una función JavaScript estándar: se puede usar directamente en una expresión [{{ }}], sin ninguna sintaxis especial.
Este componente no realiza ninguna llamada HTTP por sí mismo: muestra los datos recibidos mediante props y notifica a su padre (App.vue) las intenciones del usuario mediante los eventos [book]/[cancel], exactamente la misma separación de responsabilidades que entre [Angular] y [React].
6.10.4. src/app/features/booking-dialog/BookingDialog.vue
Port de [booking-dialog.component.ts/.html] ([Angular]) y de [BookingDialog.tsx] ([React]): la ventana (modal) que permite seleccionar un paciente para reservar un horario disponible. Equivale al ejemplo 9 del cliente AngularJS 1.x original.
Analicemos este código:
- línea 35: [template v-if="open"] : un [<template>] (una etiqueta propia de [Vue.js], que NO produce ningún elemento) lleva el [v-if]: no se carga nada en el DOM hasta que se abre el modal; es el equivalente exacto de [if (!open) return null;] del lado de [React] y de [@if(open())] del lado de [Angular];
- línea 36: [div class="modal-backdrop fade show"] : el fondo semitransparente que oscurece el resto de la página; aquí está escrito directamente en el código, como en las otras dos variantes, mientras que [Bootstrap] normalmente lo inserta él mismo mediante JavaScript cuando se muestra el modal;
- línea 38: [div class="modal fade show d-block"] : [d-block] asume el papel que normalmente cumple el JavaScript de [Bootstrap] (añadir [display:block] al abrir); aquí, es el [v-if] de la línea 35 el que cumple directamente este papel;
- línea 44: [:aria-label="t(‘BOOKING_DIALOG.CLOSE_ARIA’)"] : a diferencia de [attr.aria-label="‘BOOKING_DIALOG.CLOSE_ARIA’ | translate"] del lado de [Angular] (un enlace de atributo distinto de la interpolación {{ }}), y de manera muy parecida a [JSX] y [React] (que no distinguen entre un atributo y el contenido de un elemento), [Vue.js] utiliza aquí [:aria-label="..."]; el prefijo [:] indica un ENLACE de atributo (una expresión JavaScript) en lugar de una cadena literal.
Como en las otras dos variantes, este componente utiliza las clases REALES de [Bootstrap] para un modal, pero su visibilidad la controla [Vue.js] (un [v-if] sobre la [open] propiedad) en lugar del JavaScript de [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)]), para evitar que cada uno gestione por su cuenta la misma información (¿está abierto el modal?), una fuente frecuente de errores sutiles. El documento original (2014) utilizaba un componente de la biblioteca angular-ui-bootstrap (un modal “listo para usar”), ya diseñado según este mismo principio.
6.11. El componente raíz App: orquestador y guardián de la autenticación
Este componente cumple el papel que desempeñaba el “controlador principal” en la aplicación AngularJS 1.x original, así como el de los componentes App de los lados [Angular] y [React] : mantiene el estado global de la aplicación y responde a los eventos de los componentes de features/ para llamar a [useAppointmentService()] en el momento adecuado. Desde que se añadió la autenticación, ha asumido un segundo papel: el de “guardián” en la capa de presentación, que decide si se muestra la pantalla de inicio de sesión o el resto de la aplicación. Un componente [Vue.js] combina en un único archivo [.vue] lo que [Angular] separa en tres (app.ts, app.html, app.css), exactamente como ya lo hacía App.tsx para [React].
6.11.1. src/app/App.vue
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | |
Comentemos este código:
- líneas 25–26: [const lastDoctorId = ref<number | null>(null); const lastDay = ref<string | null>(null);] : se almacena la última búsqueda (médico + día) para poder actualizar la agenda después de una reserva o una cancelación. Como en [React] (un [useRef](), no un [useState]()), estos dos valores nunca se usan directamente para mostrar información (a diferencia de la agenda o las páginas de error); pero, a diferencia de [React], [Vue.js] no exige un hook especial ([useRef]) para una variable que sobrevive a los renderizados sin provocar un redibujado: como un [<script setup>] se ejecuta una sola vez por instancia de componente (a diferencia de una función de componente [React], que se vuelve a ejecutar en cada renderizado), una simple variable JavaScript (let) habría funcionado igual de bien; [ref()] se usa aquí simplemente por coherencia con el resto del archivo;
- líneas 28–36: [watch(() => auth.isLoggedIn, (isLoggedIn) => { if (isLoggedIn) { loadInitialLists(); } }, { immediate: true });] : vuelve a ejecutar su cuerpo cada vez que [auth.isLoggedIn] cambia; es el equivalente directo de [effect(() => { if (this.auth.isLoggedIn()) { … } })] del lado de [Angular] y de [useEffect](..., [auth.isLoggedIn]) del lado de [React]. [{ immediate: true }] hace además que se ejecute de inmediato la primera vez, sin esperar un cambio; es exactamente el comportamiento de [useEffect]() del lado de [React] (que siempre se ejecuta al menos una vez, en la inicialización): si ya había una sesión almacenada en [localStorage] (recarga de la página), las listas se cargan de inmediato al arrancar, sin esperar un inicio de sesión;
- líneas 112–133: [div class="btn-group btn-group-sm" … FR … EN … template v-if="auth.isLoggedIn" …] : el selector de idioma es SIEMPRE visible (incluso en la pantalla de inicio de sesión); en cambio, la insignia de rol, el nombre y el botón de cierre de sesión solo se muestran si [auth.isLoggedIn] (líneas 126–132, [template v-if="auth.isLoggedIn"]), exactamente la misma lógica que en [Angular] y en [React];
- línea 152: [Login v-if="!auth.isLoggedIn"] : mientras [useAuth().isLoggedIn] sea false, este componente muestra únicamente <Login />; como todas las rutas del servidor están ahora protegidas por [JwtAuthGuard] (Capítulo 3), de todos modos sería inútil (y provocaría errores 401) cargar los médicos, los clientes y la agenda antes de iniciar sesión; exactamente el mismo razonamiento que en [Angular] y en [React];
- líneas 154–171: [template v-else … DoctorDayPicker … Schedule … BookingDialog …] : aquí se ensamblan los tres componentes de “lógica de negocio” de features/, cada uno con sus props (datos, con el prefijo [:]) y sus manejadores de eventos (con el prefijo [@]); es el equivalente exacto de la plantilla app.html del lado de [Angular], donde los mismos tres componentes aparecían con [doctors]="doctors()" (search)="onSearchSchedule($event)"…
El estado ([ref]), el efecto ([watch]) y los manejadores de eventos (las funciones onXxx): son exactamente los mismos elementos ya presentados en el capítulo anterior, aplicados aquí al componente raíz completo; no se ha introducido nada nuevo en este archivo, simplemente se ha ensamblado.
6.12. Guía paso a paso del uso de la aplicación
Las siguientes capturas de pantalla se obtuvieron con exactamente la misma secuencia de acciones que en las variantes [Angular] y [React] de este curso, con este cliente [Vue.js]: URL del servidor con su valor predeterminado (http://localhost:8080), cuentas de demostración admin/admin y user/user.
6.12.1. 1. Pantalla de inicio de sesión
Cuando la página se carga por primera vez, [useAuth().isLoggedIn] vale false (no hay sesión en localStorage): solo se muestra <Login />.

Pantalla de inicio de sesión
Un intento con una combinación no válida de usuario y contraseña muestra el mensaje de error almacenado por Login.vue:

Error de inicio de sesión
El selector FR/EN, que sigue visible, traduce también esta pantalla (y el mensaje de error almacenado, que se vuelve a traducir sin código adicional; véase Login.vue más arriba):

Pantalla de inicio de sesión en francés
6.12.2. 2. Inicio de sesión como administrador (rol ADMIN, acceso completo)
Una vez iniciada la sesión con admin/admin, App.vue deja de mostrar <Login /> y carga los médicos y clientes ([loadInitialLists()], activado por [watch(() => auth.isLoggedIn, …, { immediate: true })] en la línea 28):

Página de inicio, con la sesión iniciada como ADMIN

Página de inicio, tras iniciar sesión como ADMIN, en francés
Tras seleccionar un médico y una fecha en <DoctorDayPicker />, se muestra la agenda con los botones “Book”/“Cancel” (canEdit vale true para el rol ADMIN):

Agenda, vista ADMIN (botones Book/Cancel visibles)
Al hacer clic en “Book” se abre <BookingDialog /> ([open] pasa a ser true; véase [onBookingRequest] en App.vue):

Ventana de reserva (modal de Bootstrap)
Tras la confirmación ([onConfirmBooking] llama a [api.addAppointment(...)], y luego [loadSchedule()] actualiza la pantalla), el horario aparece como reservado:

Agenda después de la reserva
Al hacer clic en “Cancel” ([onCancelAppointment] llama a [api.deleteAppointment(...)]) el horario vuelve a quedar disponible:

Agenda después de la cancelación
6.12.3. 3. Inicio de sesión como usuario (rol USER, solo lectura)
Tras cerrar la sesión (onLogout), al iniciar sesión con la cuenta user/user se muestra una insignia “USER” distinta:

Página de inicio, con la sesión iniciada como USER
La agenda sigue siendo visible, pero no aparecen los botones “Book”/“Cancel”: la columna de acciones está vacía para cada horario (véase Schedule.vue, [v-if="canEdit"] en el botón). Una solicitud directa al servidor (por ejemplo, con Postman y proporcionando el token del usuario) recibiría igualmente una respuesta 403 Forbidden: ocultar el botón es solo una comodidad de visualización; la restricción real la aplica [RolesGuard] en el lado del servidor (Capítulo 3):

Agenda, vista USER (solo lectura, sin botones de acción)
6.13. Lo que queda fuera del alcance o se ha aplazado
El modo “debug” (visualización de la plantilla sin procesar de la vista actual) del cliente AngularJS 1.x original es una funcionalidad que se ha omitido deliberadamente en este port, al igual que en las variantes [Angular] y [React] de este curso; no aparecerá en una etapa posterior del curso (véase el Capítulo 6, Conclusión, para conocer las razones de esta decisión). En cambio, la configuración de un retraso de red artificial sí se aplaza a una etapa posterior en las tres variantes.
Vale la pena mencionar aquí dos diferencias adicionales, propias de este port a [Vue.js]:
- las pruebas unitarias (que no existen en este proyecto, como tampoco en los proyectos [Angular] y [React] de este curso) seguirían un enfoque diferente en [Vue.js]: en lugar de TestBed (propio de [Angular]) o de [React Testing Library] ([React]), el ecosistema [Vue.js] suele recurrir a [Vue Test Utils], que no se presenta en este documento;
- la verificación de tipos del [<template>] tiene aquí un estatus especial: a diferencia de [React] (donde basta el compilador estándar de TypeScript, ya que [JSX] no es más que otra forma de JavaScript), [Vue.js] provee [vue-tsc] (véase package.json, Capítulo 5) específicamente PARA este fin, que verifica los tipos dentro del [<template>]; una situación que, en este punto concreto, se parece más a [Angular] y strictTemplates que a [React], aunque se trate de una herramienta aparte y no de una opción del propio compilador.