Skip to content

4. Roteamento

4.1. Exemplo 17: o roteador

Uma aplicação [Angular] é uma aplicação de página única: o navegador carrega apenas uma página HTML. No entanto, a aplicação [RdvMedecins] tem várias páginas (/login, /schedule, /doctors...), cada uma com sua própria URL, que pode ser adicionada aos favoritos ou recarregada. Este é o papel do roteador do Angular: ele associa cada URL a um componente — a “página” — e exibe esse componente quando a URL muda, sem fazer nenhuma requisição ao servidor.

17-router/src/
├── app/
│   ├── pages/
│   │   ├── home.ts
│   │   ├── doctor-list.ts
│   │   ├── doctor-detail.ts
│   │   ├── search.ts
│   │   ├── about.ts
│   │   └── not-found-page.ts
│   ├── data.ts             three "hard-coded" doctors
│   ├── app.routes.ts       the routes
│   ├── app.config.ts       the configuration of the application
│   ├── app.ts
│   └── app.html
├── index.html
└── main.ts

4.1.1. As rotas

// =========================================================================
// 17-router/src/app/app.routes.ts - as ROTAS da aplicação
// -------------------------------------------------------------------------
// Uma aplicação Angular é uma aplicação de página única (SPA: Single
// Page Application): o navegador carrega apenas UMA página HTML. Quando um
// link interno é clicado, nenhuma requisição é enviada ao servidor: o
// roteador muda o endereço exibido pelo navegador e substitui o
// componente exibido em <router-outlet>.
//
// Uma rota associa um CAMINHO a um COMPONENTE (uma "página"):
//   'doctors/:id'    :id é um parâmetro (/doctors/2 -> id = "2");
//   '**'             qualquer caminho: a página "não encontrado". As
//                    rotas são testadas em ordem: ela vem por ÚLTIMO.
// title: o título da aba do navegador quando a página é exibida.
// =========================================================================

import { Routes } from '@angular/router';
import { Home } from './pages/home';
import { DoctorList } from './pages/doctor-list';
import { DoctorDetail } from './pages/doctor-detail';
import { Search } from './pages/search';
import { NotFoundPage } from './pages/not-found-page';

export const routes: Routes = [
  { path: '', component: Home, title: 'Home' },
  { path: 'doctors', component: DoctorList, title: 'Doctors' },
  { path: 'doctors/:id', component: DoctorDetail, title: 'A doctor' },
  { path: 'search', component: Search, title: 'Search' },
  // Carregamento TARDIO (lazy loading): o código desta página só é baixado na
  // primeira visita (o compilador o transforma em um arquivo separado)
  { path: 'about', loadComponent: () => import('./pages/about'), title: 'About' },
  // um redirecionamento: o endereço antigo leva ao novo
  { path: 'physicians', redirectTo: 'doctors' },
  { path: '**', component: NotFoundPage, title: 'Page not found' },
];
  • linha 24: as rotas formam um array de objetos do tipo [Routes];
  • linha 25: o caminho vazio: a página inicial, no endereço /. Nunca se coloca uma / no início de um caminho;
  • linha 27: [:id] é um parâmetro: /doctors/1, /doctors/2... todos exibem o componente [DoctorDetail], que recebe o valor de [id];
  • linha 31: [loadComponent] substitui [component]: o componente só é carregado na primeira visita à página. O compilador armazena seu código em um arquivo separado, que é baixado nesse momento; isso acelera o tempo de carregamento da aplicação. Faremos isso para todas as páginas do estudo de caso;
  • linha 33: um redirecionamento: /physicians leva a /doctors;
  • linha 34: [**]: qualquer caminho. Como os caminhos são testados em ordem, este só é usado se nenhum dos outros servir: é a página “página não encontrada”;
  • [title]: o título da aba do navegador quando a página é exibida.

4.1.2. Configuração da aplicação

// =========================================================================
// 17-router/src/app/app.config.ts
// -------------------------------------------------------------------------
// provideRouter(routes): adicionamos o roteador à aplicação, com suas
// rotas (app.routes.ts). withComponentInputBinding(): os parâmetros do
// endereço (/doctors/:id, ?q=...) são passados aos componentes das páginas
// como INPUTS (input()) - veja pages/doctor-detail.ts.
// =========================================================================

import { ApplicationConfig } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';

export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes, withComponentInputBinding())],
};

Até agora, a configuração da aplicação ficava no arquivo [main.ts]. Ela agora é armazenada separadamente em [app.config.ts], como nos projetos criados pelo comando [ng new]:

  • Linha 15: [provideRouter] adiciona o roteador à aplicação, junto com suas rotas. [withComponentInputBinding()] passa os parâmetros do endereço aos componentes de página como entradas ([input()], Exemplo 10): esta é a maneira mais simples de lê-los.
// =========================================================================
// 17-router/src/main.ts
// -------------------------------------------------------------------------
// A configuração da aplicação (seus "providers") fica armazenada à parte,
// em app.config.ts: é a organização habitual de um projeto Angular.
// =========================================================================

import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { App } from './app/app';

bootstrapApplication(App, appConfig).catch((error) => console.error(error));
  • Linha 12: [bootstrapApplication] recebe a configuração.
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example 17 - the router</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
  <app-root></app-root>
</body>
</html>
  • linha 6: [<base href="/">]: o endereço a partir do qual o roteador calcula os caminhos. Sem ele, endereços com vários níveis (/doctors/2) não funcionariam.

4.1.3. O shell da aplicação

O componente raiz se torna um shell: ele contém os elementos comuns a todas as páginas (neste caso, o título e os links) e um espaço onde a página atual é exibida.

// =========================================================================
// 17-router/src/app/app.ts - o "shell" da aplicação
// -------------------------------------------------------------------------
//   - routerLink="...": um link interno. Em uma tag <a>, produz um
//     href de verdade, mas um clique não recarrega a página: o roteador
//     age. routerLinkActive="active" define a classe "active" (a do
//     Bootstrap) no link da página exibida;
//   - <router-outlet />: o lugar onde o componente da
//     rota atual é exibido.
// =========================================================================

import { Component, inject } from '@angular/core';
import { toSignal } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { filter, map } from 'rxjs';

@Component({
  selector: 'app-root',
  imports: [RouterLink, RouterLinkActive, RouterOutlet],
  templateUrl: './app.html',
})
export class App {
  private readonly router = inject(Router);

  // o endereço atual, como um signal: router.events é um fluxo
  // (Observable, veja o exemplo 19) de eventos de navegação; guardamos o
  // fim de cada navegação, e toSignal o transforma em um signal
  protected readonly address = toSignal(
    this.router.events.pipe(
      filter((e) => e instanceof NavigationEnd),
      // decodeURIComponent: %20 volta a ser um espaço
      map((e) => decodeURIComponent(e.urlAfterRedirects)),
    ),
    { initialValue: '' },
  );
}
  • linha 19: as diretivas do roteador usadas pelo template;
  • linhas 28–35: a URL atual, exibida abaixo dos links. [router.events] é um observable (um fluxo de eventos, como mostra o Exemplo 19) que sinaliza cada etapa da navegação. Mantemos apenas os finais de navegação (linha 30), extraímos deles o endereço — incluindo eventuais redirecionamentos (linha 32) — e [toSignal] transforma o fluxo em um signal utilizável no template.
<div class="container py-4">
  <h1 class="h3 mb-3">Example 17 - the router</h1>
  <nav class="nav nav-pills mb-3">
    <!-- routerLinkActiveOptions exact: "/" não deve estar ativo em /doctors -->
    <a class="nav-link" routerLink="/" routerLinkActive="active" [routerLinkActiveOptions]="{ exact: true }">Home</a>
    <a class="nav-link" routerLink="/doctors" routerLinkActive="active">Doctors</a>
    <!-- [queryParams]: os parâmetros após o ? (/search?q=general practitioner);
         queryParams: 'ignored': o link permanece ativo qualquer que seja a busca -->
    <a class="nav-link" routerLink="/search" [queryParams]="{ q: 'general practitioner' }" routerLinkActive="active"
       [routerLinkActiveOptions]="{ paths: 'exact', queryParams: 'ignored', fragment: 'ignored', matrixParams: 'ignored' }">Search</a>
    <a class="nav-link" routerLink="/about" routerLinkActive="active">About</a>
    <a class="nav-link" routerLink="/physicians">/physicians (redirection)</a>
    <a class="nav-link" routerLink="/unknown-page">Broken link</a>
  </nav>
  <p class="small text-muted">current address: <code>{{ address() }}</code></p>
  <div class="card p-3">
    <router-outlet />
  </div>
</div>
  • Linha 5: [routerLink]: um link interno. Para uma tag [<a>], ele gera um atributo [href] válido (o link pode ser aberto em uma nova aba), mas clicar nele não recarrega a página: é o roteador que altera o endereço e a exibição. [routerLinkActive="active"] aplica a classe [active] (derivada do [Bootstrap]) ao link da página exibida. Sem a opção [exact], o link / estaria ativo em todas as páginas, já que todos os endereços começam com /;
  • linhas 9–10: [[queryParams]]: os parâmetros colocados depois do [?] na URL (/search?q=general practitioner). A opção [queryParams: 'ignored'] mantém o link ativo independentemente da busca;
  • linhas 12–13: um link para o redirecionamento e um link para um endereço que não existe;
  • linha 17: [<router-outlet />]: o local onde o componente da rota atual é exibido.

4.1.4. As páginas

// dados "fixos no código", para não depender de um servidor neste exemplo
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
}

export const DOCTORS: Doctor[] = [
  { id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
  { id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
  { id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];
import { Component } from '@angular/core';

@Component({
  selector: 'app-home',
  template: `
    <p class="mb-0">Welcome. Click on the links: the address of the browser changes, the page is never
      reloaded (open the Network tab of the developer tools to check it). The Back and
      Forward buttons of the browser work, as well as reloading (F5) any page.</p>
  `,
})
export class Home {}

Uma página é um componente comum. Não há nada de especial nela.

// 17-router/src/app/pages/doctor-list.ts - links com um parâmetro
import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { DOCTORS } from '../data';

@Component({
  selector: 'app-doctor-list',
  imports: [RouterLink],
  template: `
    <ul class="mb-0">
      @for (m of doctors; track m.id) {
        <!-- [routerLink] com um array: o roteador monta o endereço /doctors/2 -->
        <li><a [routerLink]="['/doctors', m.id]">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</a></li>
      }
    </ul>
  `,
})
export class DoctorList {
  protected readonly doctors = DOCTORS;
}
  • Linha 13: [[routerLink]] recebe aqui um array: o roteador monta o endereço a partir de seus elementos (/doctors/2).
// =========================================================================
// 17-router/src/app/pages/doctor-detail.ts - uma página com um parâmetro
// -------------------------------------------------------------------------
// O parâmetro :id chega como um INPUT (graças a withComponentInputBinding,
// veja app.config.ts), como string: basta declarar um
// input com o mesmo nome. O componente deixa então de depender do
// roteador: ele também poderia ser usado como <app-doctor-detail id="2">.
// Router.navigate(...): navegar POR CÓDIGO; Location.back(): voltar
// à página anterior, como o botão Voltar do navegador.
// =========================================================================

import { Component, computed, inject, input } from '@angular/core';
import { Location } from '@angular/common';
import { Router } from '@angular/router';
import { DOCTORS } from '../data';

@Component({
  selector: 'app-doctor-detail',
  template: `
    @if (doctor(); as m) {
      <h2 class="h5">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</h2>
      <p>Specialty: {{ m.specialty }}</p>
      <div class="d-flex gap-2">
        <button class="btn btn-sm btn-outline-secondary" (click)="back()">Back</button>
        <button class="btn btn-sm btn-outline-primary" (click)="next()">Next doctor</button>
      </div>
    } @else {
      <p class="text-danger mb-0">Doctor no. {{ id() }} does not exist.</p>
    }
  `,
})
export class DoctorDetail {
  readonly id = input.required<string>();
  private readonly router = inject(Router);
  private readonly location = inject(Location);

  // computed: ao ir de /doctors/1 para /doctors/2, o Angular REAPROVEITA
  // o mesmo componente e só muda o input id - o computed acompanha
  protected readonly doctor = computed(() => DOCTORS.find((m) => m.id === Number(this.id())) ?? null);

  protected back(): void {
    this.location.back();
  }

  protected next(): void {
    const id = (Number(this.id()) % DOCTORS.length) + 1;
    this.router.navigate(['/doctors', id]);
  }
}
  • linha 33: o parâmetro de rota [:id] é passado à entrada de mesmo nome. Como tudo o que vem de um endereço, é uma string;
  • linha 39: o médico exibido é calculado a partir da entrada. Ao passar de /doctors/1 para /doctors/2, o [Angular] não recria o componente: ele apenas altera o valor da entrada, e [computed] acompanha;
  • linhas 27–29: um identificador desconhecido (/doctors/9) é sinalizado;
  • linha 42: [Location.back()]: volta à página anterior, como o botão Voltar do navegador;
  • linha 47: [Router.navigate]: navegação disparada pelo código, com o mesmo array de [[routerLink]].
// =========================================================================
// 17-router/src/app/pages/search.ts - uma página controlada pela URL
// -------------------------------------------------------------------------
// /search?q=pediatrician: como no formulário GET do curso de NestJS, a
// página é inteiramente descrita pelo seu endereço: pode ser salva nos favoritos,
// recarregada, revisitada com o botão Voltar. O parâmetro q também chega
// como um input do componente.
// =========================================================================

import { Component, computed, inject, input, linkedSignal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { DOCTORS } from '../data';

@Component({
  selector: 'app-search',
  imports: [FormsModule],
  template: `
    <form class="d-flex gap-2 mb-3" (ngSubmit)="search()">
      <input name="input" class="form-control" placeholder="name or specialty" [(ngModel)]="input">
      <button class="btn btn-primary">Search</button>
    </form>
    <ul class="mb-0">
      @for (m of results(); track m.id) {
        <li>{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</li>
      } @empty {
        <li class="text-muted">No result.</li>
      }
    </ul>
  `,
})
export class Search {
  readonly q = input<string>(); // ?q=... (undefined se ausente)
  private readonly router = inject(Router);

  // o campo começa com o valor da URL e a acompanha se ela mudar
  // (botão Voltar), continuando editável: um linkedSignal
  protected readonly input = linkedSignal(() => this.q() ?? '');

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

  protected search(): void {
    // alteramos a URL; a exibição acompanha a URL (input q)
    this.router.navigate(['/search'], { queryParams: { q: this.input() } });
  }
}

Esta página é totalmente descrita por seu endereço, assim como a de um formulário GET: você pode adicioná-la aos favoritos, recarregá-la ou voltar a ela com o botão Voltar.

  • Linha 33: o parâmetro [q] do endereço também é passado como entrada; se estiver ausente, seu valor é [undefined];
  • linha 38: o campo de entrada é um [linkedSignal]: ele assume o valor do endereço, é atualizado quando o endereço muda (com o botão Voltar), mas continua editável pelo usuário;
  • linhas 40–43: os resultados dependem do endereço, e não do campo de entrada: eles só mudam quando o formulário é enviado;
  • linha 47: o envio do formulário altera o endereço, o que altera a entrada [q], o que altera os resultados.
// 17-router/src/app/pages/about.ts - uma página carregada sob demanda
// "export default": loadComponent: () => import('./pages/about') encontra
// o componente sem precisar nomeá-lo
import { Component } from '@angular/core';

@Component({
  selector: 'app-about',
  template: `<p class="mb-0">This page was downloaded on the first visit (Network tab: a file
    chunk-XXXX.js). Its tab title comes from the route.</p>`,
})
export default class About {}
  • linha 11: [export default]: a função [loadComponent] da rota ([import('./pages/about')]) encontra o componente sem precisar especificar seu nome.
import { Component, inject } from '@angular/core';
import { Router } from '@angular/router';

@Component({
  selector: 'app-not-found-page',
  template: `<p class="text-danger mb-0">No page at the address <code>{{ address }}</code>.</p>`,
})
export class NotFoundPage {
  protected readonly address = inject(Router).url;
}
  • Linha 9: [Router.url]: o endereço solicitado.

4.1.5. Execução

[npm start 17-router]; clique em “Doctors” e depois em “Paul” TATOU:

Image

Clique em “Search”, digite “pediatrician” e pressione Enter: o endereço muda.

Image

O link quebrado leva a um erro de "página não encontrada":

Image

Você pode verificar na aba Network das ferramentas do desenvolvedor do navegador que nenhuma página é solicitada ao servidor quando você clica, exceto na primeira visita à página “About” (um arquivo chamado [chunk-XXXX.js]). Você também pode recarregar qualquer página (F5): o servidor de desenvolvimento sempre retorna [index.html], e o roteador exibe a página correspondente ao endereço. Um servidor de produção deve fazer o mesmo: é o que o servidor JSON fará durante a implantação.

4.2. Exemplo 18: guards de navegação e páginas

Certas páginas da aplicação [RdvMedecins] são restritas: a agenda exige login, e o gerenciamento de médicos exige o papel ADMIN. No lado do servidor, o curso de [NestJS] usou controles de acesso ([JwtAuthGuard], [RolesGuard]). O roteador do [Angular] tem os seus próprios: funções chamadas antes de exibir uma rota, que podem permitir a navegação ou redirecioná-la para outro endereço.

Este exemplo simula a conexão sem servidor: três contas estão fixas no código.

18-guards/src/app/
├── pages/
│   ├── home.ts             public page
│   ├── login.ts            public page
│   ├── schedule.ts         requires being logged in
│   └── administration.ts   requires the ADMIN role
├── session.service.ts      the logged-in user
├── guards.ts               the guards
├── app.routes.ts
├── app.config.ts
├── app.ts
└── app.html

4.2.1. A sessão

// =========================================================================
// 18-guards/src/app/session.service.ts - uma sessão SIMULADA (sem servidor)
// -------------------------------------------------------------------------
// O usuário logado, em um serviço raiz: todos os componentes e
// todos os guards que o injetam compartilham o mesmo. (O exemplo 23 fará a
// mesma coisa com um servidor real.)
// =========================================================================

import { Injectable, signal } from '@angular/core';

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

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

// três contas "fixas no código" (senha = login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };

@Injectable({ providedIn: 'root' })
export class SessionService {
  private readonly _user = signal<User | null>(null);
  readonly user = this._user.asReadonly();

  logIn(login: string, password: string): boolean {
    const role = Object.hasOwn(ACCOUNTS, login) ? ACCOUNTS[login] : undefined;
    if (role === undefined || password !== login) {
      return false;
    }
    this._user.set({ login, role });
    return true;
  }

  logOut(): void {
    this._user.set(null);
  }
}
  • Linha 11: os três papéis da aplicação [RdvMedecins];
  • linha 19: três contas, cada uma com uma senha igual ao nome de usuário;
  • linhas 23–24: o usuário conectado ([null] se não houver nenhum), em um signal que somente o serviço pode modificar. Como há apenas um serviço, os componentes e os guards que o injetam enxergam todos o mesmo usuário;
  • linha 27: [Object.hasOwn]: apenas as chaves próprias do objeto [ACCOUNTS] são mantidas. Sem essa precaução, o login “constructor” encontraria uma propriedade herdada por todos os objetos [JavaScript];
  • Linhas 26–33: o login é bem-sucedido se a conta existir e a senha estiver correta.

4.2.2. Os guards

// =========================================================================
// 18-guards/src/app/guards.ts - GUARDS de navegação
// -------------------------------------------------------------------------
// Um guard (CanActivateFn) é uma função que o roteador chama ANTES de
// exibir uma rota que o declara (canActivate: [...]). Ele retorna:
//   - true      : a navegação continua;
//   - uma UrlTree (um endereço, construído por router.createUrlTree): a
//     navegação é substituída por um redirecionamento a este endereço.
// Um guard pode injetar serviços (inject): ele roda no
// contexto de injeção da aplicação.
//
// É o equivalente, no lado do cliente, dos guards do NestJS (JwtAuthGuard,
// RolesGuard) - com uma diferença FUNDAMENTAL: um guard do cliente é
// apenas uma comodidade. O código do cliente está nas mãos do usuário, que
// pode modificá-lo à vontade. A proteção real dos dados continua sendo a
// do SERVIDOR (veja o capítulo sobre a caixa-preta).
// =========================================================================

import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
import { Role, SessionService } from './session.service';

// a página exige estar logado
export const loginRequired: CanActivateFn = (_route, state) => {
  if (inject(SessionService).user() !== null) {
    return true;
  }
  // não logado: para a página de login, lembrando para onde queríamos ir
  return inject(Router).createUrlTree(['/login'], { queryParams: { redirect: state.url } });
};

// a página exige um dos papéis listados nos dados da rota (data.roles)
export const roleRequired: CanActivateFn = (route, state) => {
  const roles = route.data['roles'] as Role[];
  const user = inject(SessionService).user();
  if (user !== null && roles.includes(user.role)) {
    return true;
  }
  // logado, mas sem o papel adequado: de volta à página inicial, com um motivo
  return inject(Router).createUrlTree(['/'], { queryParams: { denied: state.url } });
};
  • linha 24: um guard é uma função do tipo [CanActivateFn]. O roteador lhe passa a rota a ativar e o estado da navegação (que contém o endereço solicitado, [state.url]);
  • linha 25: um guard pode injetar serviços, usando [inject], como um componente;
  • linha 26: [true]: a navegação continua;
  • linha 29: caso contrário, o guard retorna outro endereço, gerado por [createUrlTree]: a navegação é substituída por um redirecionamento para a página de login. O parâmetro [redirect] guarda a página solicitada, para voltar a ela após o login;
  • linha 34: [route.data]: os dados livres declarados pela rota (aqui, os papéis autorizados). O mesmo guard é, assim, usado para todas as páginas restritas, qualquer que seja o papel exigido;
  • linha 40: um usuário conectado cujo papel não é adequado é redirecionado para a página inicial, junto com o motivo da negação.

Os comentários das linhas 12–16 são essenciais: um guard no lado do cliente é apenas uma comodidade para o usuário, que evita abrir uma página que talvez não funcione. O código do lado do cliente é executado no navegador; o usuário pode lê-lo e modificá-lo. A proteção dos dados continua sendo responsabilidade do servidor, que verifica as permissões a cada requisição.

4.2.3. Rotas protegidas

// =========================================================================
// 18-guards/src/app/app.routes.ts - rotas PROTEGIDAS
// -------------------------------------------------------------------------
//   - canActivate: os guards a passar, em ordem;
//   - data       : informação livre associada à rota (aqui, os
//                  papéis autorizados), que o guard lê.
// =========================================================================

import { Routes } from '@angular/router';
import { loginRequired, roleRequired } from './guards';
import { Home } from './pages/home';
import { Login } from './pages/login';
import { Schedule } from './pages/schedule';

export const routes: Routes = [
  { path: '', component: Home },
  { path: 'login', component: Login },
  { path: 'schedule', component: Schedule, canActivate: [loginRequired] },
  {
    path: 'administration',
    // carregamento tardio: o código só é baixado depois de passar pelos guards
    loadComponent: () => import('./pages/administration'),
    canActivate: [loginRequired, roleRequired],
    data: { roles: ['ADMIN'] },
  },
  { path: '**', redirectTo: '' },
];
  • linha 18: [canActivate]: a lista de guards da rota;
  • linha 22: a página de administração é carregada sob demanda: seu código só é baixado se os guards a autorizarem;
  • linha 23: dois guards, chamados em ordem: primeiro, estar conectado; segundo, ter o papel correto;
  • linha 24: os papéis autorizados, lidos pelo guard [roleRequired];
  • linha 26: qualquer endereço desconhecido redireciona para a página inicial.
1
2
3
4
5
6
7
import { ApplicationConfig } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';

export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes, withComponentInputBinding())],
};

A configuração é a mesma do exemplo anterior.

4.2.4. As páginas

// =========================================================================
// 18-guards/src/app/pages/login.ts
// -------------------------------------------------------------------------
// Depois de fazer login, o usuário é enviado de volta à página que queria
// abrir (parâmetro ?redirect=... definido pelo guard), ou à página inicial.
// router.navigateByUrl: navegar para um endereço completo (/schedule?x=1).
// =========================================================================

import { Component, inject, input, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { SessionService } from '../session.service';

@Component({
  selector: 'app-login',
  imports: [FormsModule],
  template: `
    @if (redirect()) {
      <p class="alert alert-warning">Log in to open {{ redirect() }}.</p>
    }
    <form class="d-flex flex-wrap gap-2" (ngSubmit)="submit()">
      <input name="login" class="form-control w-auto" placeholder="login" autocomplete="username" [(ngModel)]="login">
      <input name="password" type="password" class="form-control w-auto" placeholder="password"
             autocomplete="current-password" [(ngModel)]="password">
      <button class="btn btn-primary">Log in</button>
    </form>
    @if (error()) {
      <p class="text-danger mt-2 mb-0">Incorrect login or password.</p>
    }
  `,
})
export class Login {
  readonly redirect = input<string>();
  private readonly session = inject(SessionService);
  private readonly router = inject(Router);
  protected readonly login = signal('');
  protected readonly password = signal('');
  protected readonly error = signal(false);

  protected submit(): void {
    this.error.set(!this.session.logIn(this.login().trim(), this.password()));
    if (!this.error()) {
      const redirect = this.redirect();
      // aceitamos apenas um caminho INTERNO: ele começa com /, mas não com //
      // (//site.com/... designa OUTRO site) - nenhum redirecionamento para outro site
      const internal = redirect !== undefined && redirect.startsWith('/') && !redirect.startsWith('//');
      this.router.navigateByUrl(internal ? redirect : '/');
    }
  }
}
  • Linha 33: o parâmetro [redirect], colocado no endereço pelo guard, é recebido;
  • linhas 18–20: ele é exibido ao usuário;
  • linha 41: a conexão;
  • linhas 43–47: em caso de sucesso, o usuário é redirecionado para a página solicitada ([navigateByUrl] aceita uma URL completa, incluindo parâmetros) ou para a página inicial. O parâmetro [redirect] vem da URL: qualquer pessoa pode criar um link para /login?redirect=//malicious-site.com. A linha 46 aceita, portanto, apenas um caminho interno à aplicação.
import { Component, input } from '@angular/core';

@Component({
  selector: 'app-home',
  template: `
    <!-- ?denied=...: definido pelo guard roleRequired quando o papel não confere -->
    @if (denied()) {
      <p class="alert alert-danger">Your role does not allow you to open {{ denied() }}.</p>
    }
    <p class="mb-0">Public page. Try the two other links, logged in or not (admin, pelissier, martin -
      password = login).</p>
  `,
})
export class Home {
  readonly denied = input<string>();
}
  • Linha 15: o motivo de uma negação, enviado pelo guard [roleRequired].
import { Component, inject } from '@angular/core';
import { SessionService } from '../session.service';

@Component({
  selector: 'app-schedule',
  template: `<p class="mb-0">The schedule of <strong>{{ session.user()?.login }}</strong>: this page requires being logged in.</p>`,
})
export class Schedule {
  protected readonly session = inject(SessionService);
}
1
2
3
4
5
6
7
8
import { Component } from '@angular/core';

@Component({
  selector: 'app-administration',
  template: `<p class="mb-0">Administration: page reserved for the ADMIN role, loaded on demand (Network tab:
    its chunk-XXXX.js file is only downloaded on the first visit).</p>`,
})
export default class Administration {}

4.2.5. O shell

import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { SessionService } from './session.service';

@Component({
  selector: 'app-root',
  imports: [RouterLink, RouterLinkActive, RouterOutlet],
  templateUrl: './app.html',
})
export class App {
  protected readonly session = inject(SessionService);
  private readonly router = inject(Router);

  protected onLogOut(): void {
    this.session.logOut();
    this.router.navigate(['/']);
  }
}
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 18 - navigation guards</h1>
  <nav class="d-flex gap-3 align-items-center mb-3">
    <a routerLink="/" routerLinkActive="fw-bold" [routerLinkActiveOptions]="{ exact: true }">Home</a>
    <a routerLink="/schedule" routerLinkActive="fw-bold">Schedule (logged in)</a>
    <a routerLink="/administration" routerLinkActive="fw-bold">Administration (ADMIN)</a>
    <span class="ms-auto">
      @if (session.user(); as u) {
        {{ u.login }} <span class="badge text-bg-primary">{{ u.role }}</span>
        <button class="btn btn-sm btn-link" (click)="onLogOut()">log out</button>
      } @else {
        <a routerLink="/login">log in</a>
      }
    </span>
  </nav>
  <div class="card p-3"><router-outlet /></div>
</div>
  • Linhas 8–13: o usuário conectado e seu papel, ou um link para a página de login;
  • linha 10: sair da sessão leva o usuário de volta à página inicial (app.ts, linhas 14–17).

4.2.6. Execução

[npm start 18-guards]; sem estar conectado, clique em Administration: o guard [loginRequired] redireciona para a página de login, mantendo a página solicitada.

Image

Entre como martin, que tem o papel USER: após o login, você é redirecionado para /administration; desta vez, o guard [roleRequired] nega a navegação.

Image

Conectado como admin, o mesmo link abre a página de administração.