Skip to content

6. Capítulo 5 - El cliente [React] de la aplicación [RdvMedecins]

Este capítulo detalla, archivo por archivo, el contenido de la carpeta [rdvmedecins-react-client] incluida con este documento, usando el formato adoptado a lo largo de este curso: código fuente numerado línea por línea, seguido de una sección “Comentemos este código:”. Cada carpeta del proyecto contiene además su propio [README.md].

6.1. Descripción general de la arquitectura

Como en el documento original, el cliente sigue una arquitectura en capas, a la que aquí llamaremos V-Services (Vista-Servicios):

Image

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 separadas, vinculadas por $scope. En [React], se combinan en una sola entidad, el componente (véase el capítulo anterior), exactamente como en [Angular], aunque la forma difiera (una función en lugar de una clase); 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 con el servidor: este papel está reservado exclusivamente a la capa de servicios (aquí, el hook useAppointmentService() y el contexto AuthContext). Es un principio de diseño que se aplica por igual a AngularJS 1.x y a [Angular] y [React]; no ha cambiado.

6.2. Árbol del proyecto

Image

Image

Este desglose sigue directamente el flujo del documento original (inicio de sesión, selección de médico/día, visualización de la agenda, reserva), organizado aquí simplemente en componentes funcionales [React] en lugar de controladores/vistas separados de AngularJS 1.x, o de componentes standalone de [Angular]. Hay dos diferencias estructurales respecto de la estructura de directorios de [Angular] de este curso:

  • el componente raíz consta de tres archivos (App.tsx, App.css, README.md) en lugar de cinco (app.ts, app.html, app.css, app.config.ts, app.routes.ts): [JSX] fusiona la clase y la plantilla, y [React] no tiene un archivo de configuración de la aplicación equivalente a app.config.ts (véase “Configuración de la aplicación” más abajo);
  • Aparece una carpeta `core/context/` que no existe en la variante [Angular]: contiene los hooks personalizados y los archivos de [React] [Context] que hacen las veces de servicios inyectables ([SettingsService], [AuthService], [LanguageService]) de la variante [Angular]; este mecanismo (hooks + [Context]) se presentó en el capítulo anterior, junto con un ejemplo genérico (véase el capítulo anterior, “Compartir lógica”).

[Bootstrap] 5 se usa en todas las vistas (importado en main.tsx; véase más abajo); una evolución directa de Bootstrap 3, que ya utilizaba el documento original, y sin cambios respecto de la variante [Angular] de este curso.

6.3. Archivos de configuración del proyecto

Image

6.3.1. package.json

{
  "name": "rdvmedecins-react-client",
  "version": "0.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "dev": "vite",
    "start": "vite",
    "build": "tsc -b && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "i18next": "^25.0.0",
    "i18next-http-backend": "^3.0.0",
    "react": "^19.1.0",
    "react-dom": "^19.1.0",
    "react-i18next": "^15.0.0",
    "bootstrap": "^5.3.3"
  },
  "devDependencies": {
    "@types/react": "^19.1.0",
    "@types/react-dom": "^19.1.0",
    "@vitejs/plugin-react": "^5.0.0",
    "typescript": "~5.9.0",
    "vite": "^6.4.0"
  }
}

Comentemos este código:

  • línea 5: "type": "module", — indica a Node que este proyecto usa de forma nativa los módulos de ECMAScript (import/export) sin ninguna transformación previa; una configuración que un proyecto de la CLI de [Angular] también define, de forma implícita, en su propio conjunto de herramientas;
  • líneas 6–11: "scripts": { … } — los comandos [npm run <name>] disponibles. [start] (como `dev`) inicia el servidor de desarrollo de [Vite] con recarga automática cada vez que se modifica un archivo fuente ([Vite] llama a este mecanismo Hot Module Replacement); es el comando que se usa a lo largo de este documento, en el puerto 4200 (véase [vite.config.ts] más abajo), el mismo puerto que la variante [Angular] de este curso;
  • Líneas 12–19: "dependencies": { … } — los paquetes necesarios para ejecutar la aplicación en el navegador: [react]/[react-dom] (el núcleo de [React] y su integración con el DOM del navegador), [Bootstrap] (solo la hoja de estilos) y, agregadas en este capítulo, [i18next]/[i18next-http-backend]/[react-i18next], la biblioteca de terceros utilizada para traducir la interfaz FR/EN (véanse i18n.ts y core/context/language.context.tsx más abajo). A diferencia de la variante [Angular] de este curso, no hay un equivalente de [@angular/router] (no hay enrutador; véase el capítulo anterior), ni de RxJS ([fetch] devuelve directamente una Promise; véase el capítulo anterior);
  • líneas 20–26: "devDependencies": { … } — paquetes necesarios solo durante el desarrollo, que nunca se incluyen en el bundle final entregado al navegador: los tipos de TypeScript y de [React] ([@types/react], [@types/react-dom]; [React] está escrito en JavaScript, no en TypeScript, a diferencia de [Angular]), [@vitejs/plugin-react] (la transformación de [JSX] a JavaScript y Fast Refresh durante el desarrollo), TypeScript y [Vite] mismo.

A diferencia del servidor [NestJS] (módulo [commonjs], véase el capítulo 3), este proyecto se ejecuta con módulos nativos de ECMAScript (import/export), exactamente como la variante [Angular] de este curso (“module”: “preserve” en tsconfig.json, véase más abajo).

6.3.2. vite.config.ts

1
2
3
4
5
6
7
8
9
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [react()],
  server: {
    port: 4200,
  },
});

Analicemos este código:

  • línea 5: plugins: [react()], — habilita la transformación de [JSX]/[TSX] y la recarga en caliente; el equivalente, para [React], de lo que @angular/build:dev-server hace para [Angular] en segundo plano (véase angular.json de la variante [Angular] de este curso);
  • líneas 6–8: server: { port: 4200, }, — establece el puerto del servidor de desarrollo en 4200, el mismo que [ng serve] en [Angular]; una elección puramente didáctica, para que las dos variantes de este curso sigan siendo intercambiables sin cambiar su flujo de trabajo.

Este archivo no tiene equivalente en el proyecto AngularJS 1.x original (las herramientas de compilación de la época, Grunt y Gulp, se configuraban por separado); en [Angular] de este curso, esta función la cumple [angular.json] ; en [NestJS] (capítulo 3), es [nest-cli.json].

6.3.3. tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "preserve",
    "jsx": "react-jsx",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "skipLibCheck": true,
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true
  },
  "include": ["src"]
}

Analicemos este código:

  • línea 5: "jsx": "react-jsx", — indica al compilador de TypeScript cómo transformar el [JSX]; [react-jsx] es la configuración moderna (desde React 17), que elimina la necesidad de escribir [import React from 'react'] en cada archivo .tsx que usa [JSX]; una ligera simplificación respecto de los primeros proyectos de [React];
  • línea 6: "strict": true, — al igual que el [tsconfig.json] de la variante [Angular] de este curso, está habilitado el modo estricto completo de TypeScript: toda variable debe tener un tipo determinable y todo valor null o undefined debe manejarse explícitamente;
  • líneas 7–8: "noUnusedLocals": true, "noUnusedParameters": true, — señala durante la compilación toda variable o parámetro declarado pero nunca utilizado; una opción que la variante [Angular] de este curso no habilita de forma explícita (el compilador de [Angular] tiene sus propias verificaciones, distintas, mediante strictTemplates);
  • línea 14: "noEmit": true — aquí TypeScript se usa únicamente para la VERIFICACIÓN de tipos ([npm run build] ejecuta primero `tsc -b`, que falla si existe un error de tipos): es [Vite] (mediante esbuild) quien realmente produce el JavaScript que ejecuta el navegador, y no el compilador de TypeScript; una diferencia notable con [Angular] (ngc), que produce por sí mismo el JavaScript final.

Mientras que la variante [Angular] de este curso separa [tsconfig.json] (base común) y [tsconfig.app.json] (mediante el mecanismo de referencias de proyecto), este proyecto [React], más pequeño, consta de un solo archivo, ya que de todos modos las verificaciones de tipos de las plantillas ([Angular] y strictTemplates) no tienen equivalente aquí: es el propio compilador de TypeScript el que verifica el [JSX], como cualquier otro archivo .tsx.

6.4. Inicio de la aplicación

Image

6.4.1. index.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="icon" type="image/x-icon" href="/favicon.ico" />
    <title>RdvMedecins - React client</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

Comentemos este código:

  • línea 2: <html lang="en"> — como con [Angular], dado que esta página (HTML) es estática (el navegador la carga ANTES de que la aplicación [React] siquiera se inicie), no puede reflejar de inmediato una selección de idioma que el usuario haga después;
  • línea 10: <div id="root"></div> — el único elemento que esta página contiene inicialmente, que [React] llena por completo una vez que se inicia (véase [main.tsx] más abajo); el equivalente exacto de <app-root></app-root> en [Angular] y de [ng-app="rdvmedecinsApp"] en la etiqueta <html> del documento original (AngularJS 1.x, 2014);
  • línea 11: <script type="module" src="/src/main.tsx"></script> — primera diferencia notable con la variante [Angular] de este curso: es index.html el que hace referencia directa a main.tsx (una convención propia de [Vite]), y no al revés (un bundle de JavaScript precompilado, inyectado en la página por el proceso de compilación de [Angular]). Durante el desarrollo, [Vite] transforma y sirve este archivo .tsx sobre la marcha; en producción (npm run build), por supuesto, se compila de antemano.

Como con [Angular], hay un único 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.tsx

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { SettingsProvider } from './app/core/context/settings.context';
import { AuthProvider } from './app/core/context/auth.context';
import { LanguageProvider } from './app/core/context/language.context';
import { App } from './app/App';
import 'bootstrap/dist/css/bootstrap.min.css';
import './index.css';
import './i18n';

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <SettingsProvider>
      <AuthProvider>
        <LanguageProvider>
          <App />
        </LanguageProvider>
      </AuthProvider>
    </SettingsProvider>
  </StrictMode>,
);

Comentemos este código:

  • línea 11: createRoot(document.getElementById('root')!).render(…) — el equivalente directo de bootstrapApplication(App, appConfig) en [Angular]: inicia la aplicación en el elemento #root de index.html. El signo de exclamación (!) le indica a TypeScript que estamos seguros de que este elemento existe (se define en la línea 10 de [index.html]);
  • líneas 13–19: <SettingsProvider><AuthProvider><LanguageProvider><App /></LanguageProvider></AuthProvider></SettingsProvider> — los tres proveedores de core/context/ (véase más abajo) envuelven el componente raíz [App]: esto es lo que permite usar useSettings(), useAuth() y useLanguage() desde cualquier componente descendiente; el equivalente de los tres provideXxx() de [app.config.ts] en [Angular] (providers: [...]), pero expresado aquí como un anidamiento de componentes en lugar de una lista;
  • Línea 7: import 'bootstrap/dist/css/bootstrap.min.css'; — [Vite] permite importar una hoja de estilos directamente desde un archivo TypeScript; en [Angular], es angular.json (arreglo styles: [...]) el que cumple esta función: mismo resultado, mecanismo distinto;
  • línea 9: import './i18n'; — se importa únicamente por su efecto secundario (inicializar [i18next]; véase i18n.ts más abajo): no se usa nada de esta importación, pero su ejecución es necesaria para que [useTranslation()] funcione en los componentes.

<StrictMode> es un componente propio de [React] que afecta solo al desarrollo (no tiene efecto en producción): ayuda a detectar ciertos efectos secundarios mal escritos al ejecutar dos veces algunos renderizados; no tiene un equivalente directo en [Angular], donde en cambio el compilador detecta este tipo de errores en tiempo de compilación.

6.4.3. src/i18n.ts

import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import HttpBackend from 'i18next-http-backend';

i18n
  .use(HttpBackend)
  .use(initReactI18next)
  .init({
    lng: navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : 'en',
    fallbackLng: 'en',
    interpolation: {
      escapeValue: false,
    },
    backend: {
      loadPath: '/i18n/{{lng}}.json',
    },
  });

export default i18n;

Comentemos este código:

  • línea 6: .use(HttpBackend) — carga cada diccionario mediante una consulta HTTP GET, en la URL formada por [backend.loadPath] (línea 15): [/i18n/fr.json] o [/i18n/en.json], EXACTAMENTE la misma URL que construye [TranslateHttpLoader] en [Angular] (prefix: '/i18n/', suffix: '.json'), de modo que [public/i18n/fr.json] y [public/i18n/en.json] (véase más abajo) puedan reutilizarse tal cual, sin ninguna modificación;
  • línea 7: .use(initReactI18next) — conecta [i18next] con [React]: proporciona el hook useTranslation() que se usa en todos los componentes de features/, y el hook de React [Context] (interno de la biblioteca, no visible aquí), que provoca un nuevo renderizado completo de toda la interfaz cuando cambia el idioma; el equivalente de lo que, en [Angular], hace el decorador [TranslatePipe] combinado con [provideTranslateService(...)];
  • línea 9: lng: navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : 'en', — idioma de inicio (francés si el navegador está configurado en francés, inglés en caso contrario; fallbackLng: 'en' en la línea 10); el hook [useLanguage()] (véase core/context/language.context.tsx más abajo) lo reemplaza de inmediato por la selección almacenada en localStorage, si existe, exactamente como lang: 'en' en [app.config.ts] en [Angular];
  • líneas 11–13: interpolation: { escapeValue: false, }, — [React] ya escapa el HTML por sí mismo (protección contra vulnerabilidades XSS): no es necesario que [i18next] lo haga una segunda vez.

En el documento original (2014), el cliente AngularJS 1.x se apoyaba en la biblioteca angular-translate para esta misma necesidad; el predecesor, dentro del ecosistema AngularJS 1.x, de [@ngx-translate/core] (la variante [Angular] de este curso) y, aquí, de [i18next]. Las DOS bibliotecas modernas ([ngx-translate] en [Angular], [i18next] en [React]) cargan diccionarios JSON mediante una simple solicitud HTTP GET, con el mismo esquema de “un archivo por idioma, una sección por pantalla”.

6.4.4. src/index.css

1
2
3
4
5
6
7
body {
  background-color: #f5f7fa;
}

.free-slot:hover {
  background-color: #e9f7ef;
}

Comentemos este código:

  • línea 1: body { background-color: #f5f7fa; } — copiado exactamente de src/styles.css en [Angular]: un gris muy claro en lugar del blanco puro predeterminado, para que las tarjetas de [Bootstrap] (fondo blanco, .card) resalten ligeramente sobre el fondo de la página;
  • líneas 5–7: .free-slot:hover — se aplica a las filas de la tabla de la agenda que representan una franja disponible (véase Schedule.tsx, className={scheduleSlot.appointment === null ? 'free-slot' : undefined}, que se comenta más adelante): el fondo se vuelve ligeramente verde al pasar el mouse. El cursor en forma de mano (cursor: pointer, como se muestra en [Angular]) se aplica directamente al propio botón “Reservar” (un verdadero <button>), y no a toda la fila de la tabla.

Este archivo contiene estilos globales, a diferencia de los estilos “locales” definidos en el archivo .css de cada componente (login.css, schedule.css…), que se aplican únicamente a el [JSX] de ese componente específico; el mismo principio que en [Angular] (archivos CSS por componente). App.css, la hoja de estilos del componente raíz, permanece vacío: [Bootstrap] e index.css bastan para todo lo que implementa este documento.

6.5. La capa core/models

Image

6.5.1. src/app/core/models/appointment.models.ts

export interface ServerResponse<T> {
  status: number;
  data: T | null;
}

export interface Doctor {
  id: number;
  title: string;
  lastName: string;
  firstName: string;
}

export interface Client {
  id: number;
  title: string;
  lastName: string;
  firstName: string;
}

export interface SlotJson {
  id: number;
  startHour: number;
  startMinute: number;
  endHour: number;
  endMinute: number;
}

export interface AppointmentJson {
  id: number;
  day: string;
  client: Client | null;
  slot: SlotJson | null;
}

export interface ScheduleSlot {
  slot: SlotJson;
  appointment: AppointmentJson | null;
}

export interface DoctorDaySchedule {
  doctor: Doctor;
  day: string;
  slots: ScheduleSlot[];
}

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

export interface LoginResult {
  accessToken: string;
  login: string;
  name: string;
  role: Role;
}

Comentemos este código:

  • Este archivo es una copia directa del archivo del mismo nombre de la variante [Angular] de este curso: las interfaces de TypeScript que describen los datos intercambiados con el servidor no dependen de ninguna biblioteca de interfaces, como [React] o [Angular]. Es TypeScript “puro”, que corresponde término a término a la clase [ServerResponse]<T> y a las entidades [TypeORM] del servidor [NestJS] (capítulo 3);
  • [Client] designa aquí, como en [Angular] y en el documento original, a un PACIENTE del consultorio médico, y no debe confundirse con “cliente HTTP”;
  • Role / LoginResult — copias fieles 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, que utilizan tanto [Angular] como [React], un error tipográfico en el nombre de un campo se señala incluso antes de ejecutar el programa, en el momento de la compilación.

6.6. La capa core/context

Image

Esta carpeta no tiene equivalente en la variante [Angular] de este curso (véase el capítulo anterior, “Compartir lógica”): reúne los tres [React] [Context]s, que, en este contexto, cumplen el papel de los servicios inyectables ([SettingsService], [AuthService] y parte de [LanguageService]) en [Angular].

6.6.1. src/app/core/context/settings.context.tsx

import { createContext, useContext, useState, type ReactNode } from 'react';

interface SettingsContextValue {
  apiBaseUrl: string;
  setApiBaseUrl: (url: string) => void;
}

const SettingsContext = createContext<SettingsContextValue | null>(null);

export function SettingsProvider({ children }: { children: ReactNode }) {
  const [apiBaseUrl, setApiBaseUrl] = useState('http://localhost:8080');
  return (
    <SettingsContext.Provider value={{ apiBaseUrl, setApiBaseUrl }}>
      {children}
    </SettingsContext.Provider>
  );
}

export function useSettings(): SettingsContextValue {
  const context = useContext(SettingsContext);
  if (context === null) {
    throw new Error('useSettings() must be called under a <SettingsProvider>');
  }
  return context;
}

Comentemos este código:

  • línea 11: const [apiBaseUrl, setApiBaseUrl] = useState('http://localhost:8080'); — reemplaza a [readonly apiBaseUrl = signal('http://localhost:8080');] exactamente como lo hace [SettingsService] en [Angular]: el mismo valor predeterminado, la misma posibilidad de modificarlo desde el campo “URL del servidor” de la vista de inicio del documento original;
  • líneas 12–16: <SettingsContext.Provider value={{ apiBaseUrl, setApiBaseUrl }}>{children}</SettingsContext.Provider> — publica el par (valor, setter) para todos los descendientes, exactamente el papel que [providedIn: 'root'] cumplía en [Angular];
  • líneas 19–25: export function useSettings(): SettingsContextValue { — el hook que llaman los componentes (const settings = useSettings();), un equivalente directo de inject(SettingsService).

6.6.2. src/app/core/context/auth.context.tsx

Port de [AuthService]: gestiona la conexión del usuario, llama a [POST /login], almacena el token JWT recibido (y la identidad/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, junto con [useAppointmentService()] (véase más abajo), que se comunica con el servidor mediante HTTP.

import { createContext, useContext, useMemo, useState, type ReactNode } from 'react';
import type { LoginResult, ServerResponse, Role } from '../models/appointment.models';
import { useSettings } from './settings.context';

interface StoredSession {
  accessToken: string;
  login: string;
  name: string;
  role: Role;
}

const STORAGE_KEY = 'rdvmedecins.session';

function readStoredSession(): StoredSession | null {
  try {
    const raw = localStorage.getItem(STORAGE_KEY);
    return raw ? (JSON.parse(raw) as StoredSession) : null;
  } catch {
    return null;
  }
}

interface AuthContextValue {
  isLoggedIn: boolean;
  login: string | null;
  name: string | null;
  role: Role | null;
  isAdmin: boolean;
  accessToken: string | null;
  logIn: (login: string, password: string) => Promise<LoginResult>;
  logOut: () => void;
}

const AuthContext = createContext<AuthContextValue | null>(null);

export function AuthProvider({ children }: { children: ReactNode }) {
  const { apiBaseUrl } = useSettings();
  const [session, setSession] = useState<StoredSession | null>(readStoredSession);

  async function logIn(login: string, password: string): Promise<LoginResult> {
    const httpResponse = await fetch(`${apiBaseUrl}/login`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ login, password }),
    });
    const envelope = (await httpResponse.json()) as ServerResponse<LoginResult>;
    if (envelope.status !== 0 || envelope.data === null) {
      throw new Error('Login failed');
    }
    const result = envelope.data;
    setSession(result);
    localStorage.setItem(STORAGE_KEY, JSON.stringify(result));
    return result;
  }

  function logOut(): void {
    setSession(null);
    localStorage.removeItem(STORAGE_KEY);
  }

  const value = useMemo<AuthContextValue>(
    () => ({
      isLoggedIn: session !== null,
      login: session?.login ?? null,
      name: session?.name ?? null,
      role: session?.role ?? null,
      isAdmin: session?.role === 'ADMIN',
      accessToken: session?.accessToken ?? null,
      logIn,
      logOut,
    }),
    [session, apiBaseUrl],
  );

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
}

export function useAuth(): AuthContextValue {
  const context = useContext(AuthContext);
  if (context === null) {
    throw new Error('useAuth() must be called under an <AuthProvider>');
  }
  return context;
}

Analicemos este código:

  • Líneas 14–21: function readStoredSession(): StoredSession | null { — protegida por un bloque try/catch, exactamente como en [Angular]: [localStorage] puede no estar disponible (navegación privada muy restrictiva) o contener un valor corrupto; en ese caso, simplemente se supone que no hay sesión;
  • línea 38: const [session, setSession] = useState<StoredSession | null>(readStoredSession); — [useState(function)] ejecuta esta función solo UNA vez, durante el primer renderizado (no en cada renderizado): exactamente el papel que cumple el inicializador [signal(readStoredSession())] en [Angular]. Si el usuario recarga la página después de iniciar sesión, permanece conectado;
  • líneas 40–54: async function logIn(login: string, password: string): Promise<LoginResult> { — equivale a [POST /login, JSON body { login, password }]; a diferencia de [AuthService.logIn()] en [Angular] (que devuelve un Observable y guarda la sesión en un operador tap() separado), la versión con [fetch]/async-await encadena de forma natural los pasos de arriba hacia abajo, sin un operador dedicado;
  • líneas 56–59: function logOut(): void { — puramente local (sin llamada al servidor): en esta adaptación, un token JWT no se «revoca» en el servidor; expira por sí solo después de JWT_EXPIRES_IN (vea el .env del servidor, Capítulo 3);
  • líneas 61–73: const value = useMemo<AuthContextValue>(() => ({ … }), [session, apiBaseUrl]); — [useMemo]() evita que se vuelva a crear un nuevo objeto `value` cada vez que se renderiza [AuthProvider] cuando ni [session] ni [apiBaseUrl] han cambiado: sin él, cualquier componente que use [useAuth()] se volvería a dibujar innecesariamente cada vez que se renderizara [AuthProvider], un problema de rendimiento que no tiene un equivalente directo en el lado [Angular], donde `computed()` solo recalcula, de todos modos, lo que realmente depende de una señal modificada.

6.6.3. src/app/core/context/language.context.tsx

Adaptación de una parte de [LanguageService]: centraliza el cambio de idioma de la interfaz (francés/inglés) sobre el hook [useTranslation()] proporcionado por [react-i18next].

// src/app/core/context/language.context.tsx

import { createContext, useContext, useEffect, type ReactNode } from 'react';
import { useTranslation } from 'react-i18next';

const STORAGE_KEY = 'rdvmedecins.language';

export type Language = 'fr' | 'en';

interface LanguageContextValue {
  currentLanguage: Language;
  changeLanguage: (language: Language) => void;
}

const LanguageContext = createContext<LanguageContextValue | null>(null);

export function LanguageProvider({ children }: { children: ReactNode }) {
  const { i18n } = useTranslation();

  useEffect(() => {
    const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null;
    if (savedLanguage && savedLanguage !== i18n.language) {
      i18n.changeLanguage(savedLanguage);
      document.documentElement.lang = savedLanguage;
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  function changeLanguage(language: Language): void {
    localStorage.setItem(STORAGE_KEY, language);
    i18n.changeLanguage(language);
    document.documentElement.lang = language;
  }

  const value: LanguageContextValue = {
    currentLanguage: i18n.language as Language,
    changeLanguage,
  };

  return <LanguageContext.Provider value={value}>{children}</LanguageContext.Provider>;
}

export function useLanguage(): LanguageContextValue {
  const context = useContext(LanguageContext);
  if (context === null) {
    throw new Error('useLanguage() must be called under a <LanguageProvider>');
  }
  return context;
}

Comentemos este código:

  • línea 18: const { i18n } = useTranslation(); — [react-i18next] ya expone la instancia de i18n (y su idioma actual, i18n.language) mediante este hook: no es necesario crear un estado aparte para ello, a diferencia de [SettingsContext]/[AuthContext]; es el mismo concepto que en [Angular], donde LanguageService simplemente republica this.translate.currentLang con otro nombre;
  • líneas 20–27: useEffect(() => { … }, []); — un arreglo de dependencias vacío ([]) significa «ejecutar este efecto una sola vez, cuando el componente se monta», el equivalente directo del constructor() de [LanguageService] en el lado [Angular]: si el usuario ya había seleccionado un idioma en una visita anterior, se restablece; de lo contrario, se usa el idioma predeterminado definido en [i18n.ts] (inglés, o francés para un navegador en francés);
  • líneas 29–33: function changeLanguage(language: Language): void { — la llaman los dos botones FR/EN de la barra de navegación (vea [App.tsx] más adelante); [i18n.changeLanguage(...)] carga (si es necesario) el archivo [public/i18n/<language>.json] correspondiente y luego cambia el idioma actual; a diferencia de [translate.use(language)] en el lado [Angular] (un Observable, vea el capítulo anterior), aquí el código opta por no esperar la Promise (se resuelve muy rápido, ya que el archivo queda en caché después de la primera carga);
  • Línea 32: document.documentElement.lang = language; — actualiza el atributo <html lang="..."> de la página (útil para la accesibilidad), que ninguna de las dos bibliotecas gestiona por sí sola, ya que [index.html] es una página estática que se carga incluso antes de que arranque la aplicación; exactamente la misma necesidad y la misma solución que en [Angular].

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]) y luego de [i18next] ([React]).

6.7. Diccionarios de traducción (public/i18n/)

Image

[i18next-http-backend] (configurado en i18n.ts, vea 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). [react-i18next] luego resuelve cada clave ("LOGIN.TITLE", "SCHEDULE.FREE"…) mediante el hook [useTranslation() (function t(...))] que se usa en todos los componentes del directorio features/ (vea más adelante en este capítulo).

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / React",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "...": "..."
  },
  "DOCTOR_DAY_PICKER": { "...": "..." },
  "SCHEDULE": { "...": "..." },
  "BOOKING_DIALOG": { "...": "..." }
}

Comentemos este código:

  • Este archivo se toma tal cual de la variante [Angular] de este curso (mismas claves, mismos textos), con una sola excepción: la línea 3, ["TITLE"], que ahora hace referencia a [React] en lugar de [Angular], la única diferencia entre los dos clientes que realmente afecta el texto mostrado al usuario;
  • un objeto JSON anidado, con una sección por componente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); [i18next] lo aplana en un diccionario plano, donde cada clave completa ("LOGIN.TITLE") se forma concatenando la ruta con puntos, exactamente como [TranslateService] junto a [Angular].

6.7.2. public/i18n/en.json

1
2
3
4
5
6
{
  "APP": {
    "TITLE": "RdvMedecins - NestJS / React port",
    "...": "..."
  }
}

Analicemos este código:

  • línea 3: "TITLE": "RdvMedecins - NestJS / React port", — solo cambia el subtítulo: «[RdvMedecins]» permanece sin cambios en ambos idiomas; es el nombre propio de la aplicación.

Ambos archivos deben seguir siendo estructuralmente idénticos (las mismas claves en los dos): esto garantiza que una clave exista en ambos idiomas. Lo que NO se traduce permanece igual que en la variante [Angular] de este curso: los mensajes de error devueltos por el servidor [NestJS] siguen en inglés sin importar 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

Image

6.8.1. src/app/core/interceptors/auth.interceptor.ts

[React], al ser únicamente una biblioteca de interfaz, no tiene un concepto integrado de interceptor HTTP, como el de [HttpClient]/withInterceptors ([...]) en el lado [Angular]. Este archivo reimplementa el mismo concepto como un hook que encapsula [fetch]: es el equivalente moderno de los interceptores de $http de AngularJS 1.x, que ya se trataron en el documento original (capítulo «Ejemplo 6»).

import { useAuth } from '../context/auth.context';

export function useAuthFetch() {
  const auth = useAuth();

  return async function authFetch(input: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
    const headers = new Headers(init.headers);
    if (auth.accessToken) {
      headers.set('Authorization', `Bearer ${auth.accessToken}`);
    }
    const response = await fetch(input, { ...init, headers });
    if (response.status === 401) {
      auth.logOut();
    }
    return response;
  };
}

Analicemos este código:

  • línea 3: export function useAuthFetch() { — a diferencia de [authInterceptor] en el lado [Angular] (una función registrada de una vez por todas en [app.config.ts], que luego se aplica automáticamente a cada llamada a [HttpClient]), [useAuthFetch()] es un hook que cada llamador (aquí, useAppointmentService(), vea más adelante) debe invocar explícitamente y usar en lugar de fetch(); una diferencia de mecanismo entre las dos bibliotecas, no de comportamiento final;
  • Líneas 6–10: if (auth.accessToken) { headers.set('Authorization', …); } — el equivalente directo de [request.clone({ setHeaders: { Authorization: … } })] en el lado [Angular]. A diferencia de una solicitud de [HttpClient] (que es inmutable), las opciones de [fetch] son simplemente un objeto JavaScript: no hace falta crear una copia «clonada»; basta con construir el objeto [headers] antes de la llamada;
  • líneas 12–14: if (response.status === 401) { auth.logOut(); } — el mismo principio que en el lado [Angular] (catchError + HttpErrorResponse.status === 401): un 401 durante una sesión significa que el token ya no es válido, por lo que se cierra la sesión del cliente de manera controlada; aquí, [fetch] no rechaza su Promise con un estado HTTP como error (a diferencia de un Observable de [HttpClient]); por eso esta prueba se aplica directamente a [response.status], sin un bloque try/catch;
  • línea 15: return response; — no obstante, la respuesta (potencialmente 401) se devuelve tal cual al llamador, que sigue siendo responsable de gestionarla (vea useAppointmentService(), extract<T>(), más adelante); el interceptor no debe ocultar el error al código que realiza la llamada.

Podríamos agregar manualmente [Authorization: Bearer ...] a cada uno de los métodos de [useAppointmentService()]. Un hook 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 solo lugar.

6.9. La capa core/services

Image

6.9.1. src/app/core/services/appointment.service.ts

Adaptación de [AppointmentService]: la parte de la aplicación (la ÚNICA, junto con [core/context/auth.context.tsx] para la conexión propiamente dicha) que se comunica por HTTP con el servidor [NestJS]. Es el equivalente directo del servicio [dao] presentado en el capítulo «Ejemplo 6: los servicios HTTP» del documento original (que usaba el servicio $http de AngularJS).

import { useCallback } from 'react';
import { useAuthFetch } from '../interceptors/auth.interceptor';
import { useSettings } from '../context/settings.context';
import type { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';

async function extract<T>(httpResponse: Response): Promise<T> {
  const envelope = (await httpResponse.json()) as ServerResponse<T>;
  if (envelope.status !== 0) {
    throw new Error(`The server answered with the error status ${envelope.status}`);
  }
  return envelope.data as T;
}

export function useAppointmentService() {
  const authFetch = useAuthFetch();
  const { apiBaseUrl } = useSettings();

  const getAllDoctors = useCallback(async (): Promise<Doctor[]> => {
    const httpResponse = await authFetch(`${apiBaseUrl}/getAllDoctors`);
    return extract<Doctor[]>(httpResponse);
  }, [authFetch, apiBaseUrl]);

  const getAllClients = useCallback(async (): Promise<Client[]> => {
    const httpResponse = await authFetch(`${apiBaseUrl}/getAllClients`);
    return extract<Client[]>(httpResponse);
  }, [authFetch, apiBaseUrl]);

  const getDoctorScheduleOfDay = useCallback(
    async (doctorId: number, day: string): Promise<DoctorDaySchedule> => {
      const httpResponse = await authFetch(
        `${apiBaseUrl}/getDoctorScheduleOfDay/${doctorId}/${day}`,
      );
      return extract<DoctorDaySchedule>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  const addAppointment = useCallback(
    async (day: string, clientId: number, slotId: number): Promise<AppointmentJson> => {
      const httpResponse = await authFetch(`${apiBaseUrl}/addAppointment`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ day, clientId, slotId }),
      });
      return extract<AppointmentJson>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  const deleteAppointment = useCallback(
    async (appointmentId: number): Promise<void> => {
      const httpResponse = await authFetch(`${apiBaseUrl}/deleteAppointment`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ appointmentId }),
      });
      await extract<null>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  return { getAllDoctors, getAllClients, getDoctorScheduleOfDay, addAppointment, deleteAppointment };
}

Comentemos este código:

  • línea 6: async function extract<T>(httpResponse: Response): Promise<T> { — en lugar de repetir, en cada una de las funciones públicas, la verificación «si status !== 0, es un error», la centralizamos aquí una sola vez; exactamente el papel de [AppointmentService.extract()] en el lado [Angular], pero declarada fuera del hook (una función normal, por lo que no necesita volver a crearse en cada renderizado);
  • línea 14: export function useAppointmentService() { — un hook personalizado que se lee y se usa exactamente como [inject(AppointmentService)] en el lado [Angular]: se llama una sola vez al inicio de un componente y luego se usan las funciones que devuelve;
  • líneas 18–21: const getAllDoctors = useCallback(async () => { … }, [authFetch, apiBaseUrl]); — [useCallback]() guarda en caché esta función entre renderizados mientras [authFetch] y [[apiBaseUrl]] no cambien: esta optimización es necesaria aquí porque este hook se llama cada vez que se renderiza el componente que lo usa (App.tsx); sin ella, se volvería a crear una nueva función [getAllDoctors] en cada renderizado, lo que volvería a activar innecesariamente ciertos efectos (useEffect(…, [api]), vea App.tsx más adelante); este detalle técnico no tiene equivalente en el lado [Angular], donde [AppointmentService] existe una sola vez para toda la aplicación (providedIn: 'root');
  • cada función corresponde exactamente a una de las once rutas del controlador de [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].

A diferencia de [AuthService.logIn()] (capítulo anterior), ninguno de los métodos de este hook necesita almacenar nada después de la llamada: es el componente que llama (App.tsx) quien decide qué hacer con el resultado (setDoctors(...), setSchedule(...)…); la misma separación de responsabilidades que en el lado [Angular], donde [AppointmentService] no sabe nada del estado que se muestra en pantalla.

6.10. La capa features: los cuatro componentes

Image

6.10.1. src/app/features/login/Login.tsx

Adaptación de [login.component.ts/.html]: la pantalla de inicio de sesión, equivalente a la vista [login.html] del cliente AngularJS 1.x original.

import { useState, type FormEvent } from 'react';
import { useTranslation } from 'react-i18next';
import { useAuth } from '../../core/context/auth.context';
import './login.css';

export function Login() {
  const { t } = useTranslation();
  const auth = useAuth();

  const [login, setLogin] = useState('');
  const [password, setPassword] = useState('');
  const [submitting, setSubmitting] = useState(false);
  const [error, setError] = useState<string | null>(null);

  async function onSubmit(event?: FormEvent): Promise<void> {
    event?.preventDefault();
    if (login.trim() === '' || password === '') {
      return;
    }
    setError(null);
    setSubmitting(true);
    try {
      await auth.logIn(login, password);
      setSubmitting(false);
    } catch {
      setSubmitting(false);
      setError('LOGIN.ERROR');
    }
  }

  return (
    <div className="row justify-content-center">
      <div className="col-sm-8 col-md-6 col-lg-4">
        <form className="card p-4" onSubmit={onSubmit}>
          <h5 className="card-title mb-3">{t('LOGIN.TITLE')}</h5>
          {error && (
            <div className="alert alert-danger py-2" role="alert">
              {t(error)}
            </div>
          )}
          <div className="mb-3">
            <label className="form-label" htmlFor="input-login">
              {t('LOGIN.LOGIN_LABEL')}
            </label>
            <input id="input-login" type="text" className="form-control"
              value={login} onChange={(e) => setLogin(e.target.value)} />
          </div>
          <div className="mb-3">
            <label className="form-label" htmlFor="input-password">
              {t('LOGIN.PASSWORD_LABEL')}
            </label>
            <input id="input-password" type="password" className="form-control"
              value={password} onChange={(e) => setPassword(e.target.value)} />
          </div>
          <button type="submit" className="btn btn-primary w-100" disabled={submitting}>
            {submitting ? t('LOGIN.SUBMITTING') : t('LOGIN.SUBMIT')}
          </button>
        </form>
      </div>
    </div>
  );
}

Comentemos este código:

  • línea 6: export function Login() { — un componente standalone de [Angular] declara, en su decorador [@Component], los pipes que usa (imports: [TranslatePipe]); un componente de [React] no tiene nada equivalente que declarar: [useTranslation()]] (línea 7) simplemente se importa y se llama, como cualquier otra función;
  • líneas 10–13: const [login, setLogin] = useState(''); … — un estado puramente local del formulario (lo que el usuario está escribiendo en ese momento), equivalente a [signal()] las variables locales del componente de [Angular];
  • líneas 15–16: async function onSubmit(event?: FormEvent): Promise<void> { event?.preventDefault(); — una diferencia deliberada con respecto a la variante de [Angular] de este curso: en lugar de escuchar (keyup.enter) cada campo por separado, este componente usa un verdadero elemento <form> (línea 34) y su evento nativo [onSubmit]; tanto la tecla Enter como un clic en el botón «Iniciar sesión» (type="submit") activan entonces [onSubmit()], sin ningún código adicional; [event?.preventDefault()] evita el comportamiento predeterminado del navegador (recargar la página), que violaría el principio mismo de una aplicación de página única (SPA);
  • líneas 23–24: await auth.logIn(login, password); setSubmitting(false); — aquí no se necesita ningún procesamiento adicional: [AuthContext] ya almacenó la sesión (estado + localStorage); es App.tsx quien invoca useAuth().isLoggedIn, que responderá dejando de mostrar <Login />;
  • líneas 24–27: catch { … setError('LOGIN.ERROR'); } — un par usuario/contraseña no válido hace que [logIn()] falle con una excepción de JavaScript (lanzada por [auth.context.tsx], vea 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]. Almacenar una clave de traducción en lugar de un texto ya resuelto tiene la misma ventaja que en [Angular]: si el usuario cambia de idioma mientras se muestra este mensaje, este se traduce automáticamente (t(error), línea 38, se reevalúa en cada renderizado).

Este componente combina en UN SOLO archivo .tsx lo que [Angular] divide en dos (login.component.ts para la lógica y login.component.html para la plantilla): el [JSX] que devuelve la función Login() ES la plantilla, combinada con el código TypeScript que la controla. Por lo tanto, no hay un archivo .html aparte que comentar, a diferencia del capítulo equivalente de la variante de [Angular] de este curso.

6.10.2. src/app/features/doctor-day-picker/DoctorDayPicker.tsx

Adaptación de [doctor-day-picker.component.ts/.html]: el componente que permite seleccionar un médico y un día, y luego solicitar ver su agenda. Conceptualmente equivalente a los ejemplos 7 a 10 del cliente AngularJS 1.x original.

import { useState, type ChangeEvent } from 'react';
import { useTranslation } from 'react-i18next';
import type { Doctor } from '../../core/models/appointment.models';
import './doctor-day-picker.css';

interface DoctorDayPickerProps {
  doctors: Doctor[];
  onSearch: (criteria: { doctorId: number; day: string }) => void;
}

export function DoctorDayPicker({ doctors, onSearch }: DoctorDayPickerProps) {
  const { t } = useTranslation();
  const [selectedDoctorId, setSelectedDoctorId] = useState<number | null>(null);
  const [selectedDay, setSelectedDay] = useState<string>(
    new Date().toISOString().slice(0, 10),
  );

  function onDoctorChange(event: ChangeEvent<HTMLSelectElement>): void {
    const value = event.target.value;
    setSelectedDoctorId(value === '' ? null : Number(value));
  }

  function onSearchClick(): void {
    if (selectedDoctorId === null) {
      return;
    }
    onSearch({ doctorId: selectedDoctorId, day: selectedDay });
  }

  return (
    <div className="card p-3 mb-3">
      <div className="row g-2 align-items-end">
        <div className="col-sm-5">
          <label className="form-label" htmlFor="select-doctor">
            {t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')}
          </label>
          <select id="select-doctor" className="form-select" onChange={onDoctorChange}>
            <option value="">{t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')}</option>
            {doctors.map((doctor) => (
              <option key={doctor.id} value={doctor.id}>
                {doctor.title} {doctor.firstName} {doctor.lastName}
              </option>
            ))}
          </select>
        </div>
        <div className="col-sm-4">
          <input id="input-day" type="date" className="form-control"
            value={selectedDay} onChange={(e) => setSelectedDay(e.target.value)} />
        </div>
        <div className="col-sm-3">
          <button type="button" className="btn btn-primary w-100"
            disabled={selectedDoctorId === null} onClick={onSearchClick}>
            {t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE')}
          </button>
        </div>
      </div>
    </div>
  );
}

Comentemos este código:

  • línea 11: export function DoctorDayPicker({ doctors, onSearch }: DoctorDayPickerProps) { — un [input.required<Doctor[]>()] [Angular] simplemente se convierte en un campo del objeto `props` (`doctors`); un `output<...>()` se convierte en una prop que contiene una función de devolución de llamada proporcionada por el padre `[(onSearch)]`; `[App.tsx]` la llamará exactamente igual que se suscribía al evento `search` de la plantilla de `[Angular]` ;
  • líneas 39–43: {doctors.map((doctor) => ( <option key={doctor.id} …>…</option> ))} — .map(...), con [key={doctor.id}], es el equivalente en [React] de [@for (doctor of doctors(); track doctor.id)] en el lado [Angular]: en ambos casos, un identificador estable indica cómo reconocer a un médico que ya se mostró si se vuelve a dibujar;
  • línea 37: onChange={onDoctorChange} — a diferencia del campo «login» de [Login.tsx] (que usa [onChange] con cada pulsación de tecla), un <select> solo notifica cuando la selección realmente cambia; el mismo evento [change] de HTML que ya usaba [(change)="onDoctorChange($event)] en el lado [Angular].

6.10.3. src/app/features/schedule/Schedule.tsx

Adaptación de [schedule.component.ts/.html]: muestra la agenda de un médico para un día determinado. Equivalente a los ejemplos 8 y 9 del cliente AngularJS 1.x original. Desde la incorporación de la autenticación, este componente también acepta [canEdit]: cuando vale false (rol USER), los botones «Reservar»/«Cancelar» desaparecen; la agenda sigue siendo visible, pero en modo de solo lectura.

import { useTranslation } from 'react-i18next';
import type { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';
import './schedule.css';

interface ScheduleProps {
  schedule: DoctorDaySchedule | null;
  canEdit: boolean;
  onBook: (slot: SlotJson) => void;
  onCancel: (appointment: AppointmentJson) => void;
}

function formatTime(h: number, m: number): string {
  return `${h}:${m.toString().padStart(2, '0')}`;
}

export function Schedule({ schedule, canEdit, onBook, onCancel }: ScheduleProps) {
  const { t } = useTranslation();

  function onSlotClick(scheduleSlot: ScheduleSlot): void {
    if (!canEdit) {
      return;
    }
    if (scheduleSlot.appointment === null) {
      onBook(scheduleSlot.slot);
    } else {
      onCancel(scheduleSlot.appointment);
    }
  }

  if (schedule === null) {
    return <p className="text-muted">{t('SCHEDULE.EMPTY_STATE')}</p>;
  }

  return (
    <div className="card p-3">
      <h5>
        {t('SCHEDULE.TITLE_PREFIX')} {schedule.day} - {schedule.doctor.title} {schedule.doctor.firstName} {schedule.doctor.lastName}
      </h5>
      <table className="table table-hover align-middle">
        <thead>
          <tr><th>{t('SCHEDULE.COLUMN_SLOT')}</th><th>{t('SCHEDULE.COLUMN_STATUS')}</th><th></th></tr>
        </thead>
        <tbody>
          {schedule.slots.map((scheduleSlot) => (
            <tr key={scheduleSlot.slot.id}
              className={scheduleSlot.appointment === null ? 'free-slot' : undefined}>
              <td>
                {formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute)} -{' '}
                {formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute)}
              </td>
              <td>
                {scheduleSlot.appointment === null ? (
                  <span className="badge text-bg-success">{t('SCHEDULE.FREE')}</span>
                ) : (
                  <span className="badge text-bg-secondary">
                    {scheduleSlot.appointment.client?.title} {scheduleSlot.appointment.client?.firstName} {scheduleSlot.appointment.client?.lastName}
                  </span>
                )}
              </td>
              <td>
                {canEdit && (
                  <button type="button" className={'btn btn-sm ' +
                    (scheduleSlot.appointment === null ? 'btn-outline-success' : 'btn-outline-danger')}
                    onClick={() => onSlotClick(scheduleSlot)}>
                    {scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')}
                  </button>
                )}
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

Comentemos este código:

  • líneas 30–32: if (schedule === null) { return <p …>{t('SCHEDULE.EMPTY_STATE')}</p>; } — un retorno anticipado reemplaza a [@if (schedule(); as currentSchedule) { … } @else { … }] en el lado [Angular]: una función de componente de [React] puede devolver cualquier [JSX] en cualquier punto de su cuerpo, incluso antes del final; aquí, mientras no se haya realizado ninguna búsqueda (o la agenda esté vacía), la función se detiene después de mostrar el mensaje de estado vacío, sin siquiera construir el arreglo;
  • línea 7: canEdit: boolean; — una novedad introducida por la autenticación, similar al lado [Angular]: [App.tsx] le pasa [auth.isAdmin] (vea más adelante). Cuando vale false (rol USER), los botones «Reservar»/«Cancelar» ni siquiera existen en el DOM (vea la línea 61, [{canEdit && (…)}]); no solo aparecen en gris o deshabilitados, sino que están completamente ausentes;
  • líneas 52–58: {scheduleSlot.appointment === null ? ( <span …>Free</span> ) : ( <span …>{patient name}</span> )} — el operador ternario reemplaza a [@if (…) { … } @else { … }] en el lado [Angular]: una insignia verde de [Bootstrap] («Libre») o gris (nombre del paciente), según el estado del horario;
  • línea 61: {canEdit && (…)} — el operador && muestra su segundo operando solo si el primero es verdadero (y nada en absoluto en caso contrario); la forma más corta de renderizado condicional en [JSX], que se usa aquí en lugar del operador ternario porque no hay nada que mostrar en el otro caso;
  • línea 65: {scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')} — igual que en el lado [Angular] (donde un pipe puede usarse en cualquier expresión de la plantilla), t(...) es una función estándar de JavaScript: puede usarse directamente en un operador ternario 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.tsx) las intenciones del usuario mediante [onBook/onCancel]; exactamente la misma separación de responsabilidades que en el lado [Angular] (book/cancel, mediante output()).

6.10.4. src/app/features/booking-dialog/BookingDialog.tsx

Adaptación de [booking-dialog.component.ts/.html]: la ventana (modal) que permite seleccionar un paciente para reservar un horario disponible. Equivalente al Ejemplo 9 del cliente AngularJS 1.x original.

import { useState, type ChangeEvent } from 'react';
import { useTranslation } from 'react-i18next';
import type { Client, SlotJson } from '../../core/models/appointment.models';
import './booking-dialog.css';

interface BookingDialogProps {
  open: boolean;
  slot: SlotJson | null;
  clients: Client[];
  onConfirm: (choice: { clientId: number }) => void;
  onClose: () => void;
}

export function BookingDialog({ open, slot, clients, onConfirm, onClose }: BookingDialogProps) {
  const { t } = useTranslation();
  const [selectedClientId, setSelectedClientId] = useState<number | null>(null);

  if (!open) {
    return null;
  }

  function onClientChange(event: ChangeEvent<HTMLSelectElement>): void {
    const value = event.target.value;
    setSelectedClientId(value === '' ? null : Number(value));
  }

  function onConfirmClick(): void {
    if (selectedClientId === null) {
      return;
    }
    onConfirm({ clientId: selectedClientId });
    setSelectedClientId(null);
  }

  return (
    <>
      <div className="modal-backdrop fade show"></div>
      <div className="modal fade show d-block" tabIndex={-1} role="dialog" aria-modal="true">
        <div className="modal-dialog modal-dialog-centered">
          <div className="modal-content">
            <div className="modal-header">
              <h5 className="modal-title">{t('BOOKING_DIALOG.TITLE')}</h5>
              <button type="button" className="btn-close"
                aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} onClick={onClose}></button>
            </div>
            <div className="modal-body">
              {slot && (
                <p>
                  {t('BOOKING_DIALOG.SLOT_FROM')} {slot.startHour}:{slot.startMinute.toString().padStart(2, '0')}{' '}
                  {t('BOOKING_DIALOG.SLOT_TO')} {slot.endHour}:{slot.endMinute.toString().padStart(2, '0')}
                </p>
              )}
              <select id="select-client" className="form-select" onChange={onClientChange}>
                <option value="">{t('BOOKING_DIALOG.CHOOSE_PATIENT')}</option>
                {clients.map((client) => (
                  <option key={client.id} value={client.id}>
                    {client.title} {client.firstName} {client.lastName}
                  </option>
                ))}
              </select>
            </div>
            <div className="modal-footer">
              <button type="button" className="btn btn-secondary" onClick={onClose}>
                {t('BOOKING_DIALOG.CANCEL')}
              </button>
              <button type="button" className="btn btn-primary"
                disabled={selectedClientId === null} onClick={onConfirmClick}>
                {t('BOOKING_DIALOG.CONFIRM')}
              </button>
            </div>
          </div>
        </div>
      </div>
    </>
  );
}

Comentemos este código:

  • líneas 18–20: if (!open) { return null; } — un componente de [React] puede devolver null para no mostrar nada en absoluto: es el equivalente exacto de [@if (open()) { … }] en el lado [Angular] (nada se carga siquiera en el DOM mientras `open` sea false), y de [ngIf/ngShow] en AngularJS 1.x;
  • Línea 37: <div className="modal-backdrop fade show"></div> — el fondo semitransparente que oscurece el resto de la página; aquí está escrito directamente en el código, mientras que [Bootstrap] normalmente lo inserta por sí mismo mediante JavaScript cuando se muestra el modal;
  • línea 38: <div className="modal fade show d-block" …> — d-block reemplaza la función que normalmente cumple el JavaScript de [Bootstrap] (agregar [display:block] al abrir); aquí, es directamente el renderizado condicional de la línea 18 ([if (!open) return null;]) el que cumple esta función;
  • línea 44: aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} — a diferencia de [attr.aria-label="'BOOKING_DIALOG.CLOSE_ARIA' | translate"] en el lado [Angular] (un enlace de atributo distinto de la interpolación {{ }}), [JSX] no distingue entre un atributo HTML y el contenido de un elemento: {expression} se usa de manera idéntica en ambos lugares.

Al igual que en el lado [Angular], este componente usa las clases REALES de un modal, pero su visibilidad la controla [React] (un renderizado condicional basado en la propiedad [open]) en lugar del JavaScript de [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)]), para evitar que [Bootstrap] y [React] gestionen cada uno por su cuenta la misma información (¿está abierto el modal?), una fuente común de errores sutiles. El documento original (2014) usaba un componente de la biblioteca angular-ui-bootstrap (un modal «listo para usar» de AngularJS 1.x), que ya estaba diseñado según este mismo principio.

6.11. El componente raíz App: orquestador y guardián de la autenticación

Image

Este componente cumple el papel del «controlador principal» de la aplicación AngularJS 1.x original, y del componente App en el lado [Angular]: 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 agregó 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 de [React] combina en un solo archivo .tsx lo que [Angular] divide en tres ([app.ts, app.html, app.css]): el [JSX] que devuelve App() ES la plantilla ([App.css] se importa más abajo únicamente por su efecto secundario).

6.11.1. src/app/App.tsx

import { useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { useAuth } from './core/context/auth.context';
import { useSettings } from './core/context/settings.context';
import { useLanguage } from './core/context/language.context';
import { useAppointmentService } from './core/services/appointment.service';
import type { DoctorDaySchedule, Client, SlotJson, Doctor, AppointmentJson } from './core/models/appointment.models';
import { DoctorDayPicker } from './features/doctor-day-picker/DoctorDayPicker';
import { Schedule } from './features/schedule/Schedule';
import { BookingDialog } from './features/booking-dialog/BookingDialog';
import { Login } from './features/login/Login';
import './App.css';

export function App() {
  const { t } = useTranslation();
  const auth = useAuth();
  const settings = useSettings();
  const language = useLanguage();
  const api = useAppointmentService();

  const [doctors, setDoctors] = useState<Doctor[]>([]);
  const [clients, setClients] = useState<Client[]>([]);
  const [schedule, setSchedule] = useState<DoctorDaySchedule | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [slotBeingBooked, setSlotBeingBooked] = useState<SlotJson | null>(null);

  const lastDoctorId = useRef<number | null>(null);
  const lastDay = useRef<string | null>(null);

  useEffect(() => {
    if (auth.isLoggedIn) {
      loadInitialLists();
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [auth.isLoggedIn]);

  function loadInitialLists(): void {
    api.getAllDoctors().then(setDoctors)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
    api.getAllClients().then(setClients)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function onLogout(): void {
    auth.logOut();
    setDoctors([]); setClients([]); setSchedule(null);
    setError(null); setSlotBeingBooked(null);
    lastDoctorId.current = null; lastDay.current = null;
  }

  function onSearchSchedule(criteria: { doctorId: number; day: string }): void {
    setError(null);
    lastDoctorId.current = criteria.doctorId;
    lastDay.current = criteria.day;
    loadSchedule();
  }

  function onBookingRequest(slot: SlotJson): void {
    setSlotBeingBooked(slot);
  }

  function onConfirmBooking(choice: { clientId: number }): void {
    if (slotBeingBooked === null || lastDay.current === null) {
      return;
    }
    api.addAppointment(lastDay.current, choice.clientId, slotBeingBooked.id)
      .then(() => { setSlotBeingBooked(null); loadSchedule(); })
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function onCancelAppointment(appointment: AppointmentJson): void {
    api.deleteAppointment(appointment.id).then(() => loadSchedule())
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function loadSchedule(): void {
    if (lastDoctorId.current === null || lastDay.current === null) {
      return;
    }
    api.getDoctorScheduleOfDay(lastDoctorId.current, lastDay.current).then(setSchedule)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  return (
    <div className="container py-4">
      <nav className="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
        <span className="navbar-brand mb-0">{t('APP.TITLE')}</span>
        <div className="d-flex align-items-center gap-2">
          <div className="btn-group btn-group-sm" role="group" aria-label="FR / EN">
            <button type="button" onClick={() => language.changeLanguage('fr')}
              className={'btn ' + (language.currentLanguage === 'fr' ? 'btn-light' : 'btn-outline-light')}>FR</button>
            <button type="button" onClick={() => language.changeLanguage('en')}
              className={'btn ' + (language.currentLanguage === 'en' ? 'btn-light' : 'btn-outline-light')}>EN</button>
          </div>
          {auth.isLoggedIn && (
            <>
              <span className="badge text-bg-light text-primary">{auth.role}</span>
              <span className="text-white">{auth.name}</span>
              <button type="button" className="btn btn-sm btn-outline-light" onClick={onLogout}>
                {t('APP.LOGOUT')}
              </button>
            </>
          )}
        </div>
      </nav>

      <div className="row g-2 align-items-center mb-4">
        <div className="col-auto">
          <label className="form-label mb-0" htmlFor="input-server-url">{t('APP.SERVER_URL_LABEL')}</label>
        </div>
        <div className="col-sm-4">
          <input id="input-server-url" type="text" className="form-control form-control-sm"
            defaultValue={settings.apiBaseUrl} onChange={(e) => settings.setApiBaseUrl(e.target.value)} />
        </div>
      </div>

      {error && <div className="alert alert-danger" role="alert">{error}</div>}

      {!auth.isLoggedIn ? (
        <Login />
      ) : (
        <>
          <DoctorDayPicker doctors={doctors} onSearch={onSearchSchedule} />
          <Schedule schedule={schedule} canEdit={auth.isAdmin}
            onBook={onBookingRequest} onCancel={onCancelAppointment} />
          <BookingDialog open={slotBeingBooked !== null} slot={slotBeingBooked}
            clients={clients} onConfirm={onConfirmBooking} onClose={() => setSlotBeingBooked(null)} />
        </>
      )}
    </div>
  );
}

Comentemos este código:

  • líneas 27–28: const lastDoctorId = useRef<number | null>(null); const lastDay = useRef<string | null>(null); — almacenamos la última búsqueda (médico + día) para poder actualizar la agenda después de una reserva o una cancelación. Un [useRef](), no un [useState](): estos dos valores nunca se usan directamente para mostrar contenido (a diferencia de «schedule» o «error»), por lo que no hace falta volver a dibujar el componente cuando cambian; exactamente el mismo razonamiento por el que, en el lado [Angular], se mantenían [lastDoctorId/lastDay] como simples campos privados en lugar de señales; modificar un [useRef]() (.current = …) no vuelve a dibujar el componente, a diferencia de un [setXxx()] de [useState]();
  • líneas 30–35: useEffect(() => { if (auth.isLoggedIn) { loadInitialLists(); } }, [auth.isLoggedIn]); — vuelve a ejecutar su cuerpo cada vez que [auth.isLoggedIn] cambia; el equivalente directo de [effect(() => { if (this.auth.isLoggedIn()) { … } })] en el lado [Angular]. También se ejecuta una vez cuando el componente se monta: si ya había una sesión almacenada en [localStorage] (recarga de la página), las listas se cargan de inmediato al iniciar, sin esperar un inicio de sesión;
  • líneas 89–94: <div className="btn-group btn-group-sm" …> …FR…EN… </div> — el selector de idioma está visible (incluso en la pantalla de inicio de sesión); en cambio, la insignia del rol, el nombre y el botón de cierre de sesión solo se muestran si [auth.isLoggedIn] (líneas 95–103, [{auth.isLoggedIn && (…)})]; exactamente la misma lógica que en los lados [Angular] and [(@if (auth.isLoggedIn()) { … })] ;
  • líneas 119–130: {!auth.isLoggedIn ? ( <Login /> ): ( <>…</> )} — mientras [useAuth().isLoggedIn] sea igual a false, este componente muestra solo <Login />; dado que ahora todas las rutas del servidor están 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];
  • líneas 123–127: <DoctorDayPicker doctors={doctors} onSearch={onSearchSchedule} /> … — los tres componentes de «lógica de negocio» de features/ se ensamblan aquí, y cada uno recibe sus props (datos + funciones de devolución de llamada); el equivalente exacto de la plantilla [app.html] en el lado [Angular], donde aparecían los mismos tres componentes con [doctors]="doctors()" ([search)="onSearchSchedule($event)"]….

El estado ([useState/useRef]), el efecto ([useEffect]) y los manejadores de eventos (las funciones onXxx): son exactamente los cuatro componentes ya presentados en el capítulo anterior, aplicados aquí a todo el componente raíz; en este archivo no se ha introducido nada nuevo, simplemente se ha ensamblado.

6.12. Guía paso a paso para usar la aplicación

Las siguientes capturas de pantalla se obtuvieron con exactamente la misma secuencia de acciones que en la variante de [Angular] de este curso, con este cliente [React]: la configuración de la URL del servidor se dejó en su valor predeterminado (http://localhost:8080), con las 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] es igual a false (no hay sesión en localStorage): solo se muestra <Login />.

Image

Pantalla de inicio de sesión

Un intento con una combinación de usuario/contraseña no válida muestra el mensaje de error almacenado por [Login.tsx]:

Image

Error de inicio de sesión

El selector FR/EN, que siempre está visible, también traduce esta pantalla al francés (y el mensaje de error almacenado, que se vuelve a traducir sin código adicional; vea [Login.tsx] más arriba):

Image

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.tsx] deja de mostrar <Login /> y carga los médicos y clientes ([loadInitialLists()], activada por [useEffect(…, [auth.isLoggedIn])] en la línea 30):

Image

Página de inicio, después de iniciar sesión como ADMIN

Image

Página de inicio, después de iniciar sesión como ADMIN, en francés

Después de seleccionar un médico y una fecha en <DoctorDayPicker />, se muestra la agenda con los botones «Reservar»/«Cancelar» (canEdit vale true para el rol ADMIN):

Image

Agenda, vista ADMIN (botones Reservar/Cancelar visibles)

Al hacer clic en «Reservar» se abre <BookingDialog /> ([open] cambia a true; vea [onBookingRequest] en [App.tsx]):

Image

Ventana de reserva (modal de Bootstrap)

Después de la confirmación ([onConfirmBooking] llama a [api.addAppointment(...)], y luego [loadSchedule()] actualiza la pantalla), el horario aparece como reservado:

Image

Agenda después de la reserva

Al hacer clic en «Cancelar» ([onCancelAppointment] llama a [api.deleteAppointment(...)]) el horario vuelve a quedar disponible:

Image

Agenda después de la cancelación

6.12.3. 3. Inicio de sesión como usuario (rol USER, solo lectura)

Después de cerrar sesión (onLogout), al iniciar sesión con la cuenta user/user se muestra una insignia diferente: «USER»:

Image

Página de inicio, después de iniciar sesión como USER

La agenda sigue siendo visible, pero no aparecen los botones «Reservar»/«Cancelar»: la columna de acciones está vacía para cada horario (vea [Schedule.tsx, {canEdit && (…)}]). Una solicitud directa al servidor (por ejemplo, con Postman y proporcionando el token del usuario) seguiría recibiendo una respuesta 403 Forbidden; ocultar los botones es solo una comodidad de visualización; la restricción real la aplica [RolesGuard] en el lado del servidor (Capítulo 3):

Image

Agenda, vista USER (solo lectura, sin botones de acción)

6.13. Lo que queda fuera del alcance o pospuesto

El modo «debug» (visualización de la plantilla sin procesar de la vista actual) del cliente AngularJS 1.x original es una funcionalidad omitida deliberadamente de esta adaptación, igual que en la variante de [Angular] de este curso; no aparecerá en una etapa posterior del curso (vea el Capítulo 6, Conclusión, para conocer el razonamiento de esta decisión). En cambio, la configuración de un retardo de red artificial sí se pospone a una etapa posterior en ambas variantes.

Dos diferencias adicionales, específicas de esta adaptación a [React], merecen mencionarse aquí:

  • las pruebas unitarias (que no existen en este proyecto ni en el proyecto de [Angular] de este curso) seguirían un enfoque diferente en [React]: en lugar de TestBed (específico de [Angular]), el ecosistema de [React] suele apoyarse en [React Testing Library], que no se presenta en este documento;
  • la verificación de tipos de las plantillas ([Angular] strictTemplates, vea el capítulo anterior) no tiene un equivalente que deba configurarse por separado en el lado [React]: es el propio compilador de TypeScript el que verifica el [JSX], igual que cualquier otro archivo .tsx; una simplificación de la configuración, al costo, en teoría, de una integración algo menos profunda entre el lenguaje de plantillas y el sistema de tipos (en la práctica, en este proyecto, no hay una diferencia observable).