Skip to content

6. Capítulo 5 - O cliente [React] da aplicação [RdvMedecins]

Este capítulo detalha, arquivo por arquivo, o conteúdo da pasta [rdvmedecins-react-client] incluída neste documento, usando o formato adotado ao longo de todo o curso: código-fonte numerado linha a linha, seguido de uma seção “Vamos comentar este código:”. Cada pasta do projeto também contém o seu próprio [README.md].

6.1. Visão geral da arquitetura

Como no documento original, o cliente segue uma arquitetura em camadas, que chamaremos aqui de V-Services (View-Services):

Image

Vale notar uma diferença de terminologia: no AngularJS 1.x, a View (o template HTML) e o Controller (a classe JavaScript associada) eram duas entidades separadas, ligadas por $scope. No [React], elas são combinadas em uma única entidade, o componente (veja o capítulo anterior) — exatamente como no [Angular], embora a forma seja diferente (uma função em vez de uma classe) — e é por isso que, daqui em diante, falaremos simplesmente em “componentes” onde o documento original distinguia entre view e controller.

Como no documento original, os componentes NUNCA se comunicam diretamente com o servidor: esse papel é reservado exclusivamente à camada de Serviços (aqui, o hook useAppointmentService() e o contexto AuthContext). Este é um princípio de projeto que se aplica igualmente ao AngularJS 1.x e também ao [Angular] e ao [React] — ele não mudou.

6.2. Árvore do projeto

Image

Image

Esta divisão segue diretamente o fluxo do documento original (login, seleção de médico/dia, exibição da agenda, reserva), apenas organizada aqui em componentes funcionais [React] em vez de controllers/views separados do AngularJS 1.x, ou de componentes standalone do [Angular]. Há duas diferenças estruturais em relação à estrutura de diretórios do [Angular] deste curso:

  • o componente raiz é composto por três arquivos (App.tsx, App.css, README.md) em vez de cinco (app.ts, app.html, app.css, app.config.ts, app.routes.ts): [JSX] mescla a classe e o template, e o [React] não tem um arquivo de configuração da aplicação equivalente a app.config.ts (veja “Configuração da aplicação” abaixo);
  • Aparece uma pasta `core/context/` , ausente da variante [Angular]: ela contém os hooks personalizados e os arquivos de [React] [Context] que fazem as vezes dos serviços injetáveis ([SettingsService], [AuthService], [LanguageService]) da variante [Angular] — esse mecanismo (hooks + [Context]) foi apresentado no capítulo anterior, junto com um exemplo genérico (veja o capítulo anterior, “Compartilhando lógica”).

O [Bootstrap] 5 é usado em todas as views (importado em main.tsx; veja abaixo) — uma evolução direta do Bootstrap 3, já usado pelo documento original, e idêntico ao da variante [Angular] deste curso.

6.3. Arquivos de configuração do projeto

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"
  }
}

Vamos comentar este código:

  • linha 5: "type": "module", — informa ao Node que este projeto usa nativamente os módulos ECMAScript (import/export) sem nenhuma transformação prévia — uma configuração que um projeto [Angular] CLI também define, implicitamente, em seu próprio conjunto de ferramentas;
  • linhas 6–11: "scripts": { … } — os comandos [npm run <name>] disponíveis. [start] (como `dev`) inicia o servidor de desenvolvimento do [Vite] com recarga automática sempre que um arquivo-fonte é modificado (o [Vite] chama esse mecanismo de Hot Module Replacement) — este é o comando usado ao longo de todo este documento, na porta 4200 (veja [vite.config.ts] abaixo), a mesma porta da variante [Angular] deste curso;
  • Linhas 12–19: "dependencies": { … } — os pacotes necessários para executar a aplicação no navegador: [react]/[react-dom] (o núcleo do [React] e sua integração com o DOM do navegador), [Bootstrap] (apenas a folha de estilos) e - adicionados neste capítulo - [i18next]/[i18next-http-backend]/[react-i18next], a biblioteca de terceiros usada para traduzir a interface FR/EN (veja i18n.ts e core/context/language.context.tsx abaixo). Diferentemente da variante [Angular] deste curso, não há equivalente de [@angular/router] (nenhum roteador; veja o capítulo anterior) nem de RxJS ([fetch] retorna diretamente uma Promise; veja o capítulo anterior);
  • linhas 20–26: "devDependencies": { … } — pacotes necessários apenas durante o desenvolvimento, nunca incluídos no bundle final entregue ao navegador: os tipos do TypeScript e do [React] ([@types/react], [@types/react-dom] - o [React] em si é escrito em JavaScript, e não em TypeScript, ao contrário do [Angular]), [@vitejs/plugin-react] (a transformação de [JSX] em JavaScript e o Fast Refresh durante o desenvolvimento), o TypeScript e o próprio [Vite] .

Ao contrário do servidor [NestJS] (módulo [commonjs], veja o Capítulo 3), este projeto roda em módulos ECMAScript nativos (import/export) — exatamente como a variante [Angular] deste curso (“module”: “preserve” em tsconfig.json, veja abaixo).

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,
  },
});

Vamos detalhar este código:

  • linha 5: plugins: [react()], — ativa a transformação de [JSX]/[TSX] e o hot reloading — o equivalente, para o [React], do que @angular/build:dev-server faz para o [Angular] nos bastidores (veja angular.json da variante [Angular] deste curso);
  • linhas 6–8: server: { port: 4200, }, — define a porta do servidor de desenvolvimento como 4200, a mesma do [ng serve] no lado [Angular] — uma escolha puramente didática, para que as duas variantes do curso permaneçam intercambiáveis sem alterar o seu fluxo de trabalho.

Este arquivo não tem equivalente no projeto AngularJS 1.x original (as ferramentas de build da época — Grunt, Gulp — eram configuradas separadamente); no lado [Angular] deste curso, [angular.json] cumpre essa função; no lado [NestJS] (Capítulo 3), é [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"]
}

Vamos detalhar este código:

  • linha 5: "jsx": "react-jsx", — informa ao compilador TypeScript como transformar o [JSX]; [react-jsx] é a configuração moderna (desde o React 17), que elimina a necessidade de escrever [import React from 'react'] em todo arquivo .tsx que usa [JSX] - uma leve simplificação em comparação com os primeiros projetos [React];
  • linha 6: "strict": true, — como o [tsconfig.json] da variante [Angular] deste curso, o modo estrito completo do TypeScript está ativado: toda variável deve ter um tipo determinável, e todo valor null ou undefined deve ser tratado explicitamente;
  • linhas 7–8: "noUnusedLocals": true, "noUnusedParameters": true, — sinaliza, durante a compilação, qualquer variável ou parâmetro declarado mas nunca usado — uma configuração que a variante [Angular] deste curso não ativa explicitamente (o compilador [Angular] tem suas próprias verificações, diferentes, via strictTemplates) ;
  • linha 14: "noEmit": true — o TypeScript é usado aqui unicamente para a VERIFICAÇÃO de tipos ([npm run build] executa primeiro `tsc -b`, que falha se existir um erro de tipo): é o [Vite] (via esbuild) que de fato produz o JavaScript executado pelo navegador, e não o próprio compilador TypeScript — uma diferença notável em relação ao [Angular] (ngc), que ele próprio produz o JavaScript final.

Enquanto a variante [Angular] deste curso separa [tsconfig.json] (base comum) e [tsconfig.app.json] (por meio do mecanismo de project references), este projeto [React] menor consiste em um único arquivo — já que as verificações de tipos dos templates ([Angular] e strictTemplates) não têm equivalente aqui de qualquer modo: é o próprio compilador TypeScript que verifica o [JSX], como qualquer outro arquivo .tsx.

6.4. Iniciando a aplicação

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>

Vamos comentar este código:

  • linha 2: <html lang="en"> — como no [Angular], como esta página (HTML) é estática (carregada pelo navegador ANTES mesmo de a aplicação [React] iniciar), ela não pode refletir imediatamente uma seleção de idioma feita depois pelo usuário;
  • linha 10: <div id="root"></div> — o único elemento que esta página contém inicialmente, que o [React] preenche por inteiro assim que inicia (veja [main.tsx] abaixo) - o equivalente exato de <app-root></app-root> no lado [Angular] e de [ng-app="rdvmedecinsApp"] na tag <html> do documento original (AngularJS 1.x, 2014);
  • linha 11: <script type="module" src="/src/main.tsx"></script> — primeira diferença notável em relação à variante [Angular] deste curso: é o index.html que referencia diretamente main.tsx (uma convenção específica do [Vite]), e não o contrário (um bundle JavaScript pré-compilado, injetado na página pelo processo de build do [Angular]). Durante o desenvolvimento, o [Vite] transforma e serve esse arquivo .tsx em tempo real; em produção (npm run build), ele é, naturalmente, compilado antes.

Como no [Angular], há um único ponto de entrada para toda a aplicação: essa é a própria definição de uma aplicação web de página única (SPA), como já descrito no 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>,
);

Vamos comentar este código:

  • linha 11: createRoot(document.getElementById('root')!).render(…) — o equivalente direto de bootstrapApplication(App, appConfig) no lado [Angular]: inicia a aplicação no elemento #root de index.html. O ponto de exclamação (!) informa ao TypeScript que temos certeza de que esse elemento existe (ele é definido na linha 10 de [index.html]);
  • linhas 13–19: <SettingsProvider><AuthProvider><LanguageProvider><App /></LanguageProvider></AuthProvider></SettingsProvider> — os três providers de core/context/ (veja abaixo) envolvem o componente raiz [App]: é isso que torna useSettings(), useAuth() e useLanguage() utilizáveis a partir de qualquer componente descendente — o equivalente dos três provideXxx() de [app.config.ts] no lado [Angular] (providers: [...]), mas expresso aqui como um aninhamento de componentes em vez de uma lista;
  • Linha 7: import 'bootstrap/dist/css/bootstrap.min.css'; — o [Vite] permite importar uma folha de estilos diretamente de um arquivo TypeScript; no [Angular], é angular.json (array styles: [...]) que cumpre essa função — mesmo resultado, mecanismo diferente;
  • linha 9: import './i18n'; — importado unicamente por seu efeito colateral (inicializar o [i18next]; veja i18n.ts abaixo): nada desse import é usado, mas sua execução é necessária antes que [useTranslation()] funcione nos componentes.

<StrictMode> é um componente específico do [React] que afeta apenas o desenvolvimento (sem efeito em produção): ele ajuda a detectar certos efeitos colaterais mal escritos executando algumas renderizações duas vezes — não há equivalente direto no [Angular], em que o compilador detecta esses tipos de erro em tempo de compilação.

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;

Vamos comentar este código:

  • linha 6: .use(HttpBackend) — carrega cada dicionário por meio de uma requisição HTTP GET, na URL formada por [backend.loadPath] (linha 15): [/i18n/fr.json] ou [/i18n/en.json], EXATAMENTE a mesma URL construída por [TranslateHttpLoader] no lado [Angular] (prefix: '/i18n/', suffix: '.json'), de modo que [public/i18n/fr.json] e [public/i18n/en.json] (veja abaixo) possam ser reutilizados como estão, sem nenhuma modificação;
  • linha 7: .use(initReactI18next) — conecta o [i18next] ao [React]: fornece o hook useTranslation() usado em todo componente de features/, e o hook [Context] do React (interno à biblioteca, não visível aqui), que dispara uma nova renderização completa de toda a interface quando o idioma muda — o equivalente do que, no lado [Angular], o decorador [TranslatePipe] combinado com [provideTranslateService(...)] faz;
  • linha 9: lng: navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : 'en', — idioma inicial (francês se o navegador estiver configurado em francês, inglês caso contrário; fallbackLng: 'en' na linha 10); o hook [useLanguage()] (veja core/context/language.context.tsx abaixo) o substitui imediatamente pela seleção armazenada em localStorage, se houver — exatamente como lang: 'en' em [app.config.ts] no lado [Angular];
  • linhas 11–13: interpolation: { escapeValue: false, }, — o [React] já faz o escape de HTML por conta própria (proteção contra vulnerabilidades XSS): não há necessidade de o [i18next] fazer isso uma segunda vez.

No documento original (2014), o cliente AngularJS 1.x usava a biblioteca angular-translate para essa mesma necessidade — a predecessora, dentro do ecossistema AngularJS 1.x, de [@ngx-translate/core] (a variante [Angular] deste curso) e, aqui, de [i18next]. As DUAS bibliotecas modernas ([ngx-translate] no lado [Angular], [i18next] no lado [React]) carregam dicionários JSON por meio de uma simples requisição HTTP GET, usando o mesmo esquema “um arquivo por idioma, uma seção por tela”.

6.4.4. src/index.css

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

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

Vamos comentar este código:

  • linha 1: body { background-color: #f5f7fa; } — copiado exatamente de src/styles.css no lado [Angular]: um cinza bem claro em vez do branco puro padrão, para que os cards do [Bootstrap] (fundo branco, .card) se destaquem levemente do fundo da página;
  • linhas 5–7: .free-slot:hover — aplicado às linhas da tabela da agenda que representam um horário disponível (veja Schedule.tsx, className={scheduleSlot.appointment === null ? 'free-slot' : undefined}, discutido mais adiante): o fundo fica levemente verde ao passar o mouse. O cursor em forma de mão (cursor: pointer, como mostrado em [Angular]) é aplicado diretamente ao próprio botão “Reservar” (um verdadeiro <button>), e não à linha inteira da tabela.

Este arquivo contém estilos globais, em oposição aos estilos “locais” definidos no arquivo .css de cada componente (login.css, schedule.css…), que se aplicam apenas ao [JSX] daquele componente específico — o mesmo princípio do [Angular] (arquivos CSS por componente). App.css, a folha de estilos do componente raiz, permanece vazio: [Bootstrap] e index.css bastam para tudo o que este documento implementa.

6.5. A camada 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;
}

Vamos comentar este código:

  • Este arquivo é uma cópia direta do arquivo de mesmo nome da variante [Angular] deste curso: as interfaces TypeScript que descrevem os dados trocados com o servidor não dependem de nenhuma biblioteca de interface, como o [React] ou o [Angular] - é TypeScript “puro”, que corresponde termo a termo à classe [ServerResponse]<T> e às entidades [TypeORM] do servidor [NestJS] (Capítulo 3);
  • [Client] refere-se aqui — como no lado [Angular] e no documento original — a um PACIENTE do consultório médico — não deve ser confundido com “cliente HTTP”;
  • Role / LoginResult — cópias fiéis dos tipos de mesmo nome do servidor (src/entities/user.entity.ts, auth/login-result.model.ts, Capítulo 3).

No AngularJS 1.x (2014), o JavaScript puro não permitia descrever o formato de dados esperado dessa maneira. Com o TypeScript — usado tanto pelo [Angular] quanto pelo [React] — um erro de digitação em um nome de campo é sinalizado antes mesmo de o programa ser executado, já em tempo de compilação.

6.6. A camada core/context

Image

Esta pasta não tem equivalente na variante [Angular] deste curso (veja o capítulo anterior, “Compartilhando lógica”): ela reúne os três [React] [Context]s, que, neste contexto, cumprem o papel desempenhado pelos serviços injetáveis ([SettingsService], [AuthService] e parte de [LanguageService]) no lado [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;
}

Vamos comentar este código:

  • linha 11: const [apiBaseUrl, setApiBaseUrl] = useState('http://localhost:8080'); — substitui [readonly apiBaseUrl = signal('http://localhost:8080');] exatamente como o [SettingsService] no lado [Angular]: o mesmo valor padrão, a mesma possibilidade de modificá-lo a partir do campo “URL do servidor” da view inicial do documento original;
  • linhas 12–16: <SettingsContext.Provider value={{ apiBaseUrl, setApiBaseUrl }}>{children}</SettingsContext.Provider> — publica o par (valor, setter) para todos os descendentes, exatamente o papel que [providedIn: 'root'] desempenhava no lado [Angular];
  • linhas 19–25: export function useSettings(): SettingsContextValue { — o hook que os componentes chamam (const settings = useSettings();), um equivalente direto de inject(SettingsService).

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

Port de [AuthService]: gerencia a conexão do usuário, chama [POST /login], armazena o token JWT recebido (e a identidade/papel que o acompanham) e garante que ele sobreviva a um recarregamento da página usando [localStorage]. Este é o único lugar da aplicação, junto com [useAppointmentService()] (veja abaixo), que se comunica com o servidor por 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;
}

Vamos detalhar este código:

  • Linhas 14–21: function readStoredSession(): StoredSession | null { — protegida por um bloco try/catch, exatamente como no lado [Angular]: [localStorage] pode estar indisponível (navegação privada muito restritiva) ou conter um valor corrompido — nesse caso, simplesmente assumimos que não há sessão;
  • linha 38: const [session, setSession] = useState<StoredSession | null>(readStoredSession); — [useState(function)] executa essa função apenas UMA vez, durante a primeiríssima renderização (e não a cada renderização): exatamente o papel desempenhado pelo inicializador [signal(readStoredSession())] no lado [Angular]. Se o usuário recarregar a página depois de fazer login, ele continua conectado;
  • linhas 40–54: async function logIn(login: string, password: string): Promise<LoginResult> { — equivalente a [POST /login, JSON body { login, password }]; diferentemente de [AuthService.logIn()] no lado [Angular] (que retorna um Observable e salva a sessão em um operador tap() separado), a versão [fetch]/async-await encadeia naturalmente as etapas de cima para baixo, sem um operador dedicado;
  • linhas 56–59: function logOut(): void { — puramente local (sem chamada ao servidor): um token JWT não é “revogado” no lado do servidor neste port; ele expira por conta própria após JWT_EXPIRES_IN (veja o .env do servidor, Capítulo 3);
  • linhas 61–73: const value = useMemo<AuthContextValue>(() => ({ … }), [session, apiBaseUrl]); — [useMemo]() evita que um novo objeto `value` seja recriado a cada vez que [AuthProvider] é renderizado quando nem [session] nem [apiBaseUrl] mudaram: sem ele, qualquer componente que use [useAuth()] seria redesenhado desnecessariamente toda vez que [AuthProvider] fosse renderizado — um problema de desempenho que não tem equivalente direto no lado do [Angular], onde `computed()` de qualquer modo só recalcula o que realmente depende de um signal modificado.

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

Port de parte de [LanguageService]: centraliza a troca do idioma da interface (francês/inglês) sobre o hook [useTranslation()] fornecido 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;
}

Vamos comentar este código:

  • linha 18: const { i18n } = useTranslation(); — [react-i18next] já expõe a instância i18n (e seu idioma atual, i18n.language) por meio deste hook: não é preciso criar um estado separado para ela, ao contrário do que ocorre com [SettingsContext]/[AuthContext]; é o mesmo conceito do [Angular], onde LanguageService simplesmente republica this.translate.currentLang com outro nome;
  • linhas 20–27: useEffect(() => { … }, []); — um array de dependências vazio ([]) significa “execute este efeito apenas uma vez, quando o componente é montado” — o equivalente direto do constructor() de [LanguageService] no lado do [Angular]: se o usuário já tinha selecionado um idioma em uma visita anterior, ele é restaurado; caso contrário, é usado o idioma padrão definido em [i18n.ts] (inglês, ou francês para um navegador em francês).
  • linhas 29–33: function changeLanguage(language: Language): void { — chamada pelos dois botões FR/EN da barra de navegação (veja [App.tsx] abaixo); [i18n.changeLanguage(...)] carrega (se necessário) o arquivo [public/i18n/<language>.json] correspondente e, em seguida, troca o idioma atual — ao contrário de [translate.use(language)] no lado do [Angular] (um Observable, veja o capítulo anterior) — aqui, o código opta por não esperar a Promise (ela é resolvida muito rapidamente, pois o arquivo fica em cache após o primeiro carregamento);
  • Linha 32: document.documentElement.lang = language; — atualiza o atributo <html lang="..."> da página (útil para acessibilidade), que nenhuma das duas bibliotecas gerencia por conta própria, já que [index.html] é uma página estática carregada antes mesmo de a aplicação iniciar — exatamente a mesma necessidade e a mesma solução do [Angular].

Equivalente ao botão “FR / EN” do cliente AngularJS 1.x original, que na época usava a biblioteca [angular-translate] — a predecessora, no ecossistema AngularJS 1.x, de [ngx-translate] ([Angular]) e depois de [i18next] ([React]).

6.7. Dicionários de tradução (public/i18n/)

Image

[i18next-http-backend] (configurado em i18n.ts, veja acima) carrega um desses dois arquivos por meio de uma requisição [HTTP GET /i18n/<language>.json] sempre que o idioma muda (ou é usado pela primeira vez). [react-i18next] então resolve cada chave ("LOGIN.TITLE", "SCHEDULE.FREE"…) por meio do hook [useTranslation() (function t(...))] usado em todos os componentes da pasta features/ (veja mais adiante neste 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": { "...": "..." }
}

Vamos comentar este código:

  • Este arquivo é retirado tal qual da variante [Angular] deste curso (mesmas chaves, mesmos textos), com uma exceção: a linha 3, ["TITLE"], que agora se refere ao [React] em vez de ao [Angular] — a única diferença entre os dois clientes que realmente afeta o texto exibido ao usuário;
  • um objeto JSON aninhado, com uma seção por componente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); [i18next] o transforma em um dicionário plano, em que cada chave completa ("LOGIN.TITLE") é formada pela concatenação do caminho com pontos — exatamente como [TranslateService] no lado do [Angular].

6.7.2. public/i18n/en.json

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

Vamos detalhar este código:

  • linha 3: "TITLE": "RdvMedecins - NestJS / React port", — apenas o subtítulo muda: “[RdvMedecins]” permanece inalterado nos dois idiomas; é o nome próprio da aplicação.

Os dois arquivos devem permanecer estruturalmente idênticos (as mesmas chaves em ambos): isso garante que uma chave exista nos dois idiomas. O que NÃO é traduzido permanece inalterado em relação à variante [Angular] deste curso: as mensagens de erro retornadas pelo servidor [NestJS] continuam em inglês, qualquer que seja o idioma selecionado no lado do cliente, e os nomes dos médicos e dos pacientes vêm diretamente do banco de dados.

6.8. A camada core/interceptors

Image

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

[React], por ser apenas uma biblioteca de interface, não possui um conceito nativo de interceptor HTTP, como o [HttpClient]/withInterceptors ([...]) do lado do [Angular]. Este arquivo reimplementa o mesmo conceito como um hook que encapsula [fetch]: este é o equivalente moderno dos interceptors de $http do AngularJS 1.x, que já haviam sido tratados no documento original (capítulo “Exemplo 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;
  };
}

Vamos detalhar este código:

  • linha 3: export function useAuthFetch() { — ao contrário de [authInterceptor] no lado do [Angular] (uma função registrada uma vez por todas em [app.config.ts], que é então aplicada automaticamente a cada chamada ao [HttpClient]), [useAuthFetch()] é um hook que cada chamador (aqui, useAppointmentService(), veja abaixo) deve chamar explicitamente e usar no lugar de fetch() — uma diferença de mecanismo entre as duas bibliotecas, não de comportamento final;
  • Linhas 6–10: if (auth.accessToken) { headers.set('Authorization', …); } — o equivalente direto de [request.clone({ setHeaders: { Authorization: … } })] no lado do [Angular]. Ao contrário de uma requisição [HttpClient] (que é imutável), as opções de [fetch] são simplesmente um objeto JavaScript: não é preciso criar uma cópia “clonada” dele; basta construir o objeto [headers] antes da chamada;
  • linhas 12–14: if (response.status === 401) { auth.logOut(); } — mesmo princípio do lado do [Angular] (catchError + HttpErrorResponse.status === 401): um 401 durante uma sessão significa que o token não é mais válido, então o cliente é desconectado de forma elegante; aqui, [fetch] não rejeita sua Promise com um status HTTP como erro (ao contrário de um Observable [HttpClient]) — por isso este teste examina [response.status] diretamente, sem um bloco try/catch;
  • linha 15: return response; — a resposta (potencialmente 401) é, mesmo assim, devolvida tal como está ao chamador, que continua responsável por tratá-la (veja useAppointmentService(), extract<T>(), abaixo) — o interceptor não deve ocultar o erro do código chamador.

Poderíamos adicionar manualmente [Authorization: Bearer ...] a cada um dos métodos de [useAppointmentService()]. Um hook compartilhado evita essa repetição, oferecendo o mesmo benefício de um interceptor do [Angular]: a pergunta “Como autenticamos uma requisição?” é respondida em um único lugar.

6.9. A camada core/services

Image

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

Port de [AppointmentService]: a parte da aplicação (a ÚNICA, junto com [core/context/auth.context.tsx] para a conexão propriamente dita) que se comunica via HTTP com o servidor [NestJS]. É o equivalente direto do serviço [dao] apresentado no capítulo “Exemplo 6: os serviços HTTP” do documento original (que usava o serviço $http do 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 };
}

Vamos comentar este código:

  • linha 6: async function extract<T>(httpResponse: Response): Promise<T> { — em vez de repetir, em cada uma das funções públicas, a verificação “se status !== 0, é um erro”, nós a centralizamos aqui uma única vez — exatamente o papel de [AppointmentService.extract()] no lado do [Angular], mas declarada fora do hook (uma função comum, que, portanto, não precisa ser recriada a cada renderização);
  • linha 14: export function useAppointmentService() { — um hook personalizado que se lê e se usa exatamente como [inject(AppointmentService)] no lado do [Angular]: ele é chamado uma vez no topo de um componente e, em seguida, as funções que retorna são utilizadas;
  • linhas 18–21: const getAllDoctors = useCallback(async () => { … }, [authFetch, apiBaseUrl]); — [useCallback]() mantém esta função em cache entre as renderizações, desde que [authFetch] e [[apiBaseUrl]] não mudem: essa otimização é necessária aqui porque este hook é chamado a cada vez que o componente que o utiliza é renderizado (App.tsx) — sem ela, uma nova função [getAllDoctors] seria recriada a cada renderização, o que dispararia novamente, sem necessidade, certos efeitos (useEffect(…, [api]), veja App.tsx abaixo); esse detalhe técnico não tem equivalente no lado do [Angular], onde [AppointmentService] existe uma única vez para toda a aplicação (providedIn: 'root');
  • cada função corresponde exatamente a uma das onze rotas do controller [NestJS] (Capítulo 3) — aliás, os mesmos nomes aparecem nos dois lados (getAllDoctors, addAppointment, deleteAppointment…), o que facilita a comparação entre o lado do servidor e o do cliente, assim como no [Angular].

Ao contrário de [AuthService.logIn()] (capítulo anterior), nenhum dos métodos deste hook precisa armazenar nada após a chamada: é o componente chamador (App.tsx) que decide o que fazer com o resultado (setDoctors(...), setSchedule(...)…) — a mesma separação de responsabilidades do lado do [Angular], onde [AppointmentService] não sabe nada sobre o estado exibido na tela.

6.10. A camada features: os quatro componentes

Image

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

Port de [login.component.ts/.html]: a tela de login, equivalente à view [login.html] do 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>
  );
}

Vamos comentar este código:

  • linha 6: export function Login() { — um componente standalone do [Angular] declara, dentro de seu decorador [@Component], os pipes que utiliza (imports: [TranslatePipe]); um componente [React] não tem nada equivalente a declarar: [useTranslation()]] (linha 7) é simplesmente importado e chamado, como qualquer outra função;
  • linhas 10–13: const [login, setLogin] = useState(''); … — um estado puramente local do formulário (o que o usuário está digitando no momento), equivalente a [signal()] variáveis locais do componente [Angular];
  • linhas 15–16: async function onSubmit(event?: FormEvent): Promise<void> { event?.preventDefault(); — uma diferença deliberada em relação à variante [Angular] deste curso: em vez de escutar (keyup.enter) cada campo separadamente, este componente usa um elemento <form> de verdade (linha 34) e seu evento nativo [onSubmit] — tanto a tecla Enter quanto um clique no botão “Log in” (type="submit") disparam então [onSubmit()], sem nenhum código adicional; [event?.preventDefault()] impede o comportamento padrão do navegador (recarregar a página), que violaria o próprio princípio de uma aplicação de página única (SPA);
  • linhas 23–24: await auth.logIn(login, password); setSubmitting(false); — não é necessário nenhum processamento adicional aqui: [AuthContext] já armazenou a sessão (estado + localStorage) — é App.tsx que chama useAuth().isLoggedIn, que responderá deixando de exibir <Login />;
  • linhas 24–27: catch { … setError('LOGIN.ERROR'); } — um par usuário/senha inválido faz [logIn()] falhar com uma exceção JavaScript (lançada por [auth.context.tsx], veja acima): "LOGIN.ERROR" é exibido ao usuário, sem tentar distinguir entre um nome de usuário inexistente e uma senha incorreta — exatamente a mesma abordagem do [Angular]. Armazenar uma chave de tradução em vez de um texto já resolvido tem a mesma vantagem do [Angular]: se o usuário trocar de idioma enquanto essa mensagem estiver exibida, ela se traduz automaticamente (t(error), linha 38, reavaliado a cada renderização).

Este componente reúne em UM ÚNICO arquivo .tsx o que o [Angular] divide em dois (login.component.ts para a lógica, login.component.html para o template): o [JSX] retornado pela função Login() É o template, combinado com o código TypeScript que o controla. Portanto, não há um arquivo .html separado para comentar, ao contrário do capítulo equivalente da variante [Angular] deste curso.

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

Port de [doctor-day-picker.component.ts/.html]: o componente que permite selecionar um médico e um dia e, em seguida, solicitar a exibição de sua agenda. Conceitualmente equivalente aos exemplos 7 a 10 do 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>
  );
}

Vamos comentar este código:

  • linha 11: export function DoctorDayPicker({ doctors, onSearch }: DoctorDayPickerProps) { — um [input.required<Doctor[]>()] [Angular] passa simplesmente a ser um campo do objeto `props` (`doctors`); um `output<...>()` passa a ser uma prop que contém uma função de callback fornecida pelo pai `[(onSearch)]` — `[App.tsx]` a chamará exatamente como se inscrevia no evento `search` do template `[Angular]` ;
  • linhas 39–43: {doctors.map((doctor) => ( <option key={doctor.id} …>…</option> ))} — .map(...), com [key={doctor.id}], é o equivalente, no [React], de [@for (doctor of doctors(); track doctor.id)] no lado do [Angular]: nos dois casos, um identificador estável especifica como reconhecer um médico que já foi exibido caso ele seja redesenhado;
  • linha 37: onChange={onDoctorChange} — ao contrário do campo “login” de [Login.tsx] (que usa [onChange] a cada tecla digitada), um <select> só notifica quando a seleção realmente muda — o mesmo evento HTML [change] que já era usado por [(change)="onDoctorChange($event)] no lado do [Angular].

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

Port de [schedule.component.ts/.html]: exibe a agenda de um médico em um determinado dia. Equivalente aos exemplos 8 e 9 do cliente AngularJS 1.x original. Desde a adição da autenticação, este componente também aceita [canEdit]: quando é false (papel USER), os botões “Book”/“Cancel” desaparecem — a agenda continua visível, mas em modo somente leitura.

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>
  );
}

Vamos comentar este código:

  • linhas 30–32: if (schedule === null) { return <p …>{t('SCHEDULE.EMPTY_STATE')}</p>; } — um retorno antecipado substitui [@if (schedule(); as currentSchedule) { … } @else { … }] no lado do [Angular]: uma função de componente [React] pode retornar qualquer [JSX] em qualquer ponto de seu corpo, inclusive antes do fim — aqui, enquanto nenhuma busca tiver sido feita (ou a agenda estiver vazia), a função para depois de exibir a mensagem de estado vazio, sem sequer construir o array;
  • linha 7: canEdit: boolean; — uma novidade introduzida pela autenticação, semelhante ao lado do [Angular]: [App.tsx] passa a ele [auth.isAdmin] (veja abaixo). Quando é false (papel USER), os botões “Book”/“Cancel” sequer existem no DOM (veja a linha 61, [{canEdit && (…)}]) — não ficam apenas acinzentados ou desabilitados, mas totalmente ausentes;
  • linhas 52–58: {scheduleSlot.appointment === null ? ( <span …>Free</span> ) : ( <span …>{patient name}</span> )} — o operador ternário substitui [@if (…) { … } @else { … }] no lado do [Angular]: um selo [Bootstrap] verde (“Free”) ou cinza (nome do paciente), conforme o estado do horário;
  • linha 61: {canEdit && (…)} — o operador && exibe seu segundo operando somente se o primeiro for verdadeiro (e nada, caso contrário) — a forma mais curta de renderização condicional em [JSX], usada aqui em vez do operador ternário porque não há nada a exibir no caso contrário;
  • linha 65: {scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')} — como no lado do [Angular] (onde um pipe pode ser usado em qualquer expressão de template), t(...) é uma função JavaScript comum: pode ser usada diretamente em um operador ternário, sem nenhuma sintaxe especial.

Este componente não faz nenhuma chamada HTTP por conta própria: ele exibe os dados recebidos via props e notifica seu pai (App.tsx) sobre as intenções do usuário por meio de [onBook/onCancel] — exatamente a mesma separação de responsabilidades do lado do [Angular] (book/cancel, via output()).

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

Port de [booking-dialog.component.ts/.html]: a janela (modal) que permite selecionar um paciente para reservar um horário disponível. Equivalente ao Exemplo 9 do 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>
    </>
  );
}

Vamos comentar este código:

  • linhas 18–20: if (!open) { return null; } — um componente [React] pode retornar null para não exibir nada: este é o equivalente exato de [@if (open()) { … }] no lado do [Angular] (nada sequer é carregado no DOM enquanto `open` for false), e de [ngIf/ngShow] no AngularJS 1.x;
  • Linha 37: <div className="modal-backdrop fade show"></div> — o fundo semitransparente que escurece o restante da página — fixado diretamente no código aqui, enquanto o [Bootstrap] normalmente o insere por conta própria via JavaScript quando o modal é exibido;
  • linha 38: <div className="modal fade show d-block" …> — d-block substitui o papel normalmente desempenhado pelo JavaScript do [Bootstrap] (adicionar [display:block] ao abrir) — aqui, é diretamente a renderização condicional da linha 18 ([if (!open) return null;]) que desempenha esse papel;
  • linha 44: aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} — ao contrário de [attr.aria-label="'BOOKING_DIALOG.CLOSE_ARIA' | translate"] no lado do [Angular] (um binding de atributo distinto da interpolação {{ }}), [JSX] não faz distinção entre um atributo HTML e o conteúdo de um elemento: {expression} é usado de forma idêntica nos dois lugares.

Como no lado do [Angular], este componente usa as classes REAIS de um modal, mas sua visibilidade é controlada pelo [React] (uma renderização condicional baseada na propriedade [open]) em vez de pelo JavaScript do [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)]) — para impedir que [Bootstrap] e [React] gerenciem, cada um de forma independente, a mesma informação (o modal está aberto?), uma fonte comum de bugs sutis. O documento original (2014) usava um componente da biblioteca angular-ui-bootstrap (um modal “pronto para uso” do AngularJS 1.x), que já havia sido concebido segundo esse mesmo princípio.

6.11. O componente raiz App: orquestrador e guardião da autenticação

Image

Este componente cumpre o papel desempenhado pelo “controller principal” da aplicação AngularJS 1.x original e pelo componente App no lado do [Angular]: ele mantém o estado global da aplicação e responde aos eventos dos componentes de features/ para chamar [useAppointmentService()] no momento certo. Desde que a autenticação foi adicionada, ele assumiu um segundo papel: o de “porteiro” na camada de apresentação, que decide se exibe a tela de login ou o restante da aplicação. Um componente [React] reúne em um único arquivo .tsx o que o [Angular] divide em três ([app.ts, app.html, app.css]): o [JSX] retornado por App() É o template ([App.css] é importado abaixo apenas como efeito colateral).

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>
  );
}

Vamos comentar este código:

  • linhas 27–28: const lastDoctorId = useRef<number | null>(null); const lastDay = useRef<string | null>(null); — armazenamos a última busca (médico + dia) para poder atualizar a agenda após uma reserva ou um cancelamento. Um [useRef](), e não um [useState](): esses dois valores nunca são usados diretamente para exibição (ao contrário de “schedule” ou “error”), portanto não há necessidade de redesenhar o componente quando mudam — exatamente o mesmo raciocínio que, no lado do [Angular], manteve [lastDoctorId/lastDay] como simples campos privados em vez de signals; modificar um [useRef]() (.current = …) não redesenha o componente, ao contrário de um [setXxx()] de [useState]();
  • linhas 30–35: useEffect(() => { if (auth.isLoggedIn) { loadInitialLists(); } }, [auth.isLoggedIn]); — reexecuta seu corpo toda vez que [auth.isLoggedIn] muda — o equivalente direto de [effect(() => { if (this.auth.isLoggedIn()) { … } })] no lado do [Angular]. Ele também é executado uma vez quando o componente é montado: se uma sessão já estava armazenada em [localStorage] (recarregamento da página), as listas são carregadas imediatamente na inicialização, sem esperar por um login;
  • linhas 89–94: <div className="btn-group btn-group-sm" …> …FR…EN… </div> — o seletor de idioma fica visível (inclusive na tela de login); o selo do papel, o nome e o botão de logout, porém, só são exibidos se [auth.isLoggedIn] (linhas 95–103, [{auth.isLoggedIn && (…)})] — exatamente a mesma lógica dos lados [Angular] and [(@if (auth.isLoggedIn()) { … })] ;
  • linhas 119–130: {!auth.isLoggedIn ? ( <Login /> ): ( <>…</> )} — enquanto [useAuth().isLoggedIn] for igual a false, este componente exibe apenas <Login />; como todas as rotas do servidor agora são protegidas por [JwtAuthGuard] (Capítulo 3), seria inútil (e causaria erros 401) carregar médicos/clientes/agenda antes do login — exatamente o mesmo raciocínio do [Angular];
  • linhas 123–127: <DoctorDayPicker doctors={doctors} onSearch={onSearchSchedule} /> … — os três componentes de “lógica de negócio” de features/ são montados aqui, cada um recebendo suas props (dados + funções de callback) — o equivalente exato do template [app.html] no lado do [Angular], onde os mesmos três componentes apareciam com [doctors]="doctors()" ([search)="onSearchSchedule($event)"]….

Estado ([useState/useRef]), efeito ([useEffect]) e manipuladores de eventos (as funções onXxx): são exatamente os quatro componentes já apresentados no capítulo anterior, aplicados aqui ao componente raiz inteiro — nada de novo foi introduzido neste arquivo; ele foi simplesmente montado.

6.12. Guia passo a passo de uso da aplicação

As capturas de tela a seguir foram obtidas com exatamente a mesma sequência de ações da variante [Angular] deste curso, neste cliente [React]: a configuração da URL do servidor foi mantida em seu valor padrão (http://localhost:8080), com as contas de demonstração admin/admin e user/user.

6.12.1. 1. Tela de login

Quando a página é carregada pela primeira vez, [useAuth().isLoggedIn] é igual a false (nenhuma sessão em localStorage): apenas <Login /> é exibido.

Image

Tela de login

Uma tentativa com uma combinação inválida de usuário/senha exibe a mensagem de erro armazenada por [Login.tsx]:

Image

Erro de login

O seletor FR/EN, sempre visível, também traduz esta tela para o francês (e a mensagem de erro armazenada, que é retraduzida sem código adicional; veja [Login.tsx] acima):

Image

Tela de login em francês

6.12.2. 2. Login como administrador (papel ADMIN, acesso total)

Depois de fazer login com admin/admin, [App.tsx] deixa de exibir <Login /> e carrega os médicos/clientes ([loadInitialLists()], disparado por [useEffect(…, [auth.isLoggedIn])] na linha 30):

Image

Página inicial, após login como ADMIN

Image

Página inicial, após login como ADMIN, em francês

Depois de selecionar um médico e uma data em <DoctorDayPicker />, a agenda é exibida com os botões “Book”/“Cancel” (canEdit é definido como true para o papel ADMIN):

Image

Agenda, visão ADMIN (botões Book/Cancel visíveis)

Clicar em “Book” abre <BookingDialog /> ([open] muda para true; veja [onBookingRequest] em [App.tsx]):

Image

Janela de reserva (modal do Bootstrap)

Após a confirmação ([onConfirmBooking] calls [api.addAppointment(...)], then [loadSchedule()] atualiza a exibição), o horário aparece como reservado:

Image

Agenda após a reserva

Clicar em “Cancel” ([onCancelAppointment] chama [api.deleteAppointment(...)]) torna o horário disponível novamente:

Image

Agenda após o cancelamento

6.12.3. 3. Login como usuário (papel USER, somente leitura)

Depois de sair (onLogout), fazer login com a conta user/user exibe um selo diferente: “USER”:

Image

Página inicial, após login como USER

A agenda continua visível, mas nenhum botão “Book”/“Cancel” aparece: a coluna de ações fica vazia para cada horário (veja [Schedule.tsx, {canEdit && (…)}]). Uma requisição direta ao servidor (por exemplo, usando o Postman e fornecendo o token do usuário) ainda receberia uma resposta 403 Forbidden — ocultar os botões é apenas uma conveniência de exibição; a restrição real é imposta por [RolesGuard] no lado do servidor (Capítulo 3):

Image

Agenda, visão USER (somente leitura, sem botões de ação)

6.13. O que fica fora do escopo ou adiado

O modo “debug” (exibição do template bruto da view atual) do cliente AngularJS 1.x original é um recurso deliberadamente omitido deste port, assim como na variante [Angular] deste curso — ele não aparecerá em uma etapa posterior do curso (veja o Capítulo 6, Conclusão, para a justificativa dessa decisão). A configuração de um atraso artificial de rede, porém, de fato fica adiada para uma etapa posterior nas duas variantes.

Duas diferenças adicionais, específicas deste port em [React], merecem ser mencionadas aqui:

  • os testes unitários (ausentes tanto deste projeto quanto do projeto [Angular] deste curso) seguiriam uma abordagem diferente no [React]: em vez do TestBed (específico do [Angular]), o ecossistema [React] normalmente recorre ao [React Testing Library] — não apresentado neste documento;
  • a verificação de tipos dos templates ([Angular] strictTemplates, veja o capítulo anterior) não tem equivalente que precise ser configurado separadamente no lado do [React]: é o próprio compilador TypeScript que verifica o [JSX], como qualquer outro arquivo .tsx — uma simplificação da configuração, ao custo, em teoria, de uma integração ligeiramente menos profunda entre a linguagem de template e o sistema de tipos (na prática, neste projeto, nenhuma diferença observável).