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):

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


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

6.3.1. package.json
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
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
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

6.4.1. index.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
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
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
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

6.5.1. src/app/core/models/appointment.models.ts
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

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
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.
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].
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/)

[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
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
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

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”).
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

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).
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

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.
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.
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.
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.
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

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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | |
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.

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

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):

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):

Página inicial, após login como ADMIN

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):

Agenda, visão ADMIN (botões Book/Cancel visíveis)
Clicar em “Book” abre <BookingDialog /> ([open] muda para true; veja [onBookingRequest] em [App.tsx]):

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:

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

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”:

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):

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).